feat(compiler): bring local wing files

examples/invalid/circular-bring.w

@@ -0,0 +1 @@
+bring "./circular/mod.w";

examples/invalid/circular/mod.w

@@ -0,0 +1 @@
+bring "../circular-bring.w";

examples/simple/bring.w

@@ -0,0 +1,2 @@
+bring "./modules/mod1.w";
+bring "./modules/mod2.w";

examples/simple/modules/mod1.w

@@ -0,0 +1,2 @@
+let x = 1;
+let y = 2;

examples/simple/modules/mod2.w

@@ -0,0 +1,4 @@
+bring "./sub/mod.w";
+
+let z = 3;
+let q = 4;

examples/simple/modules/sub/mod.w

@@ -0,0 +1 @@
+let w = "what";

examples/simple/sdk_capture_test.w

@@ -1,10 +1,19 @@
 bring cloud;
 
-let bucket = new cloud.Bucket();
+let p = cloud.BucketProps {
+    public: false
+};
 
-inflight handler() {
-  bucket.upload("file.txt", "data");
-  bucket.delete("file.txt");
+let bucket = new cloud.Bucket(p);
+
+inflight handler(event: str):str {
+  bucket.put("file.txt", "data");
+  bucket.get("file.txt");
 }
 
-new cloud.Function(handler);
+new cloud.Function(
+  handler, 
+  cloud.FunctionProps {
+    env: Map<str> {}
+  }
+);

libs/tree-sitter-wing/grammar.js

@@ -21,15 +21,17 @@ module.exports = grammar({
   word: ($) => $.identifier,
 
   precedences: ($) => [
-    [$.builtin_type, $.identifier],
-    [$.custom_type, $.nested_identifier, $.reference],
+    // Handle ambiguity in case of empty literal: `a = {}`
+    // In this case tree-sitter doesn't know if it's a set or a map literal so just assume its a map
     [$.map_literal, $.set_literal],
-    [$.new_expression, $.function_call],
-    [$.nested_identifier, $.method_call, $.reference],
   ],
 
   supertypes: ($) => [$.expression, $._literal],
 
+  conflicts: $ => [
+     [$.reference, $.custom_type],
+  ],
+
   rules: {
     // Basics
     source: ($) => repeat($._statement),
@@ -41,15 +43,16 @@ module.exports = grammar({
 
     // Identifiers
     reference: ($) =>
+//      prec.right(choice($.identifier, $.nested_identifier)),
       choice($.identifier, $.nested_identifier),
 
     identifier: ($) => /([A-Za-z_$][A-Za-z_$0-9]*|[A-Z][A-Z0-9_]*)/,
 
-    custom_type: ($) =>
-      prec.right(seq(
+    custom_type: ($) => 
+      seq(
         field("object", $.identifier),
         repeat(seq(".", field("fields", $.identifier)))
-      )),
+      ),
 
     nested_identifier: ($) =>
       seq(
@@ -200,17 +203,18 @@ module.exports = grammar({
         $.new_expression,
         $._literal,
         $.reference,
-        $.function_call,
-        $.method_call,
+        $.call,
         $.preflight_closure,
         $.inflight_closure,
         $.pure_closure,
         $.await_expression,
         $._collection_literal,
         $.parenthesized_expression,
-        $.structured_access_expression
+        $.structured_access_expression,
+        $.struct_literal,
       ),
 
+
     // Primitives
     _literal: ($) => choice($.string, $.number, $.bool, $.duration),
 
@@ -253,15 +257,9 @@ module.exports = grammar({
         )
       ),
 
-    function_call: ($) =>
+    call: ($) =>
       seq(field("call_name", $.reference), field("args", $.argument_list)),
 
-    method_call: ($) =>
-      seq(
-        field("call_name", $.nested_identifier),
-        field("args", $.argument_list)
-      ),
-
     argument_list: ($) =>
       seq(
         "(",
@@ -292,7 +290,7 @@ module.exports = grammar({
     new_expression: ($) =>
       seq(
         "new",
-        field("class", choice($.custom_type, $.builtin_container_type)),
+        field("class", choice($.custom_type, $.mutable_container_type)),
         field("args", $.argument_list),
         field("id", optional($.new_object_id)),
         field("scope", optional($.new_object_scope))
@@ -306,7 +304,7 @@ module.exports = grammar({
       choice(
         seq($.custom_type, optional("?")),
         seq($.builtin_type, optional("?")),
-        seq($.builtin_container_type, optional("?")),
+        seq($._builtin_container_type, optional("?")),
         $.function_type
       ),
 
@@ -315,7 +313,7 @@ module.exports = grammar({
         seq(
           optional(field("inflight", $._inflight_specifier)),
           field("parameter_types", $.parameter_type_list),
-          optional(seq("->", field("return_type", $._type)))
+          optional(seq(":", field("return_type", $._type)))
         )
       ),
 
@@ -347,6 +345,7 @@ module.exports = grammar({
         optional("async"),
         field("name", $.identifier),
         field("parameter_list", $.parameter_list),
+        optional(field("return_type", $._type_annotation)),
         field("block", $.block)
       ),
 
@@ -357,25 +356,39 @@ module.exports = grammar({
 
     parameter_list: ($) => seq("(", commaSep($.parameter_definition), ")"),
 
-    builtin_container_type: ($) =>
+    immutable_container_type: ($) =>
       seq(
         field(
           "collection_type",
           choice(
+            "Array",
             "Set",
             "Map",
-            "Array",
-            "MutSet",
-            "MutMap",
-            "MutArray",
-            "Promise"
-          )
+          ),
+        ),
+        $._container_value_type
+      ),
+
+    mutable_container_type: ($) =>
+      choice(
+        seq(
+          field(
+            "collection_type",
+            choice(
+              "MutSet",
+              "MutMap",
+              "MutArray",
+              "Promise"
+            )
+          ),
+          $._container_value_type
         ),
-        "<",
-        field("type_parameter", $._type),
-        ">"
       ),
 
+    _builtin_container_type: ($) => choice($.immutable_container_type, $.mutable_container_type),
+
+    _container_value_type: ($) => seq("<", field("type_parameter", $._type), ">"),
+
     unary_expression: ($) =>
       choice(
         ...[
@@ -439,11 +452,21 @@ module.exports = grammar({
     _collection_literal: ($) =>
       choice($.array_literal, $.set_literal, $.map_literal),
     array_literal: ($) => seq("[", commaSep($.expression), "]"),
-    set_literal: ($) => seq("{", commaSep($.expression), "}"),
-    map_literal: ($) => seq("{", commaSep($.map_literal_member), "}"),
+    set_literal: ($) => seq(
+      optional(field("type", $.immutable_container_type)),
+      "{", commaSep($.expression), "}"
+    ),
+    map_literal: ($) => seq(
+      optional(field("type", $.immutable_container_type)),
+      "{", commaSep($.map_literal_member), "}"
+    ),
+    struct_literal: ($) => seq(field("type", $.custom_type), "{", field("fields", commaSep($.struct_literal_member)), "}"),
 
     map_literal_member: ($) =>
+      // TODO: make sure $.string here conforms to valid keys in a map
       seq(choice($.identifier, $.string), ":", $.expression),
+    struct_literal_member: ($) =>
+      seq($.identifier, ":", $.expression),
     structured_access_expression: ($) =>
       prec.right(seq($.expression, "[", $.expression, "]")),
   },