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";

libs/tree-sitter-wing/test/corpus/statements.txt

@@ -241,3 +241,18 @@ struct Test {
         )
     )
 )
+
+==================================
+Bring statement
+==================================
+
+bring cloud;
+bring "./mod.w";
+
+---
+(source
+    (short_import_statement
+        module_name: (identifier))
+    (short_import_statement
+        module_name: (string))
+)

libs/wingc/.vscode/launch.json

@@ -0,0 +1,19 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "lldb",
+      "request": "launch",
+      "name": "library 'wingc' debugger target",
+      "cargo": {
+        "args": ["test", "--no-run", "--lib", "--package=wingc"],
+        "filter": {
+          "name": "wingc",
+          "kind": "lib"
+        }
+      },
+      "args": [],
+      "cwd": "${workspaceFolder}"
+    }
+  ]
+}

libs/wingc/Cargo.toml

@@ -23,3 +23,6 @@ path = "src/bin.rs"
 [package.metadata]
 # Currently wasm-opt is not changing the size of the wasm file, so it's just adding unnecessary time to the build.
 wasm-opt = false
+
+[profile.bench]
+debug = true

libs/wingc/src/ast.rs

@@ -78,10 +78,15 @@ pub struct Constructor {
 
 #[derive(Debug)]
 pub enum Statement {
+	// TODO: merge these statements into a single one
 	Use {
 		module_name: Symbol, // Reference?
 		identifier: Option<Symbol>,
 	},
+	Bring {
+		module_path: String,
+		statements: Scope,
+	},
 	VariableDef {
 		var_name: Symbol,
 		initial_value: Expr,

libs/wingc/src/capture.rs

@@ -250,6 +250,12 @@ fn scan_captures_in_scope(scope: &Scope) -> Vec<Capture> {
 			} => {
 				todo!()
 			}
+			Statement::Bring {
+				module_path: _,
+				statements,
+			} => {
+				res.extend(scan_captures_in_scope(statements));
+			}
 			Statement::Struct {
 				name: _,
 				extends: _,

libs/wingc/src/jsify.rs

@@ -378,6 +378,15 @@ fn jsify_statement(statement: &Statement, out_dir: &PathBuf) -> String {
 					.join("\n")
 			)
 		}
+		Statement::Bring {
+			module_path,
+			statements,
+		} => format!(
+			"/* start bring module: {module} */\n{}\n/* end bring module: {module} */",
+			jsify_scope(statements, &out_dir),
+			module = module_path
+		)
+		.to_string(),
 	}
 }
 

libs/wingc/src/jsiiify.rs

@@ -0,0 +1,196 @@
+use crate::{ast::*, type_check::Types};
+use serde_json::json;
+use std::{collections::BTreeMap, fs};
+use wingii::jsii;
+
+/// generates a JSII manifest for the given scope
+pub fn jsiiify(scope: &Scope, types: &Types) -> String {
+	let mut jsii_types: BTreeMap<String, serde_json::Value> = BTreeMap::new();
+	for statement in scope.statements.iter() {
+		match statement {
+			Statement::VariableDef { .. } => {}
+			Statement::FunctionDefinition(func_def) => match func_def.signature.flight {
+				Flight::In => {}
+				Flight::Pre => {}
+			},
+			Statement::Class {
+				constructor,
+				is_resource,
+				members,
+				methods,
+				name,
+				parent,
+			} => {
+				assert!(!is_resource, "resources are not supported yet");
+				let manifest = jsii::ClassType {
+					abstract_: Some(false),
+					assembly: "wingc".to_string(),
+					base: if parent.is_some() {
+						None
+					} else {
+						None
+					},
+					docs: None,
+					fqn: format!("wingc.{}", name.name),
+					interfaces: None,
+					kind: "class".to_string(),
+					namespace: None,
+					location_in_module: None,
+					symbol_id: None,
+					name: name.name.to_string(),
+					initializer: Some(jsii::Callable {
+						docs: None,
+						location_in_module: None,
+						overrides: None,
+						protected: None,
+						variadic: None,
+						parameters: Some(
+							constructor
+								.parameters
+								.iter()
+								.map(|param| jsii::Parameter {
+									docs: None,
+									name: param.name.to_string(),
+									optional: None,
+									type_: json!({ "primitive": "any" }),
+									variadic: None,
+								})
+								.collect(),
+						),
+					}),
+					properties: Some(
+						members
+							.iter()
+							.map(|member| jsii::Property {
+								docs: None,
+								location_in_module: None,
+								name: member.name.name.to_string(),
+								optional: None,
+								protected: None,
+								abstract_: None,
+								const_: None,
+								immutable: None,
+								overrides: None,
+								static_: None,
+								type_: json!({ "primitive": "any" }),
+							})
+							.collect(),
+					),
+					methods: Some(
+						methods
+							.iter()
+							.map(|method| jsii::Method {
+								docs: None,
+								async_: None,
+								variadic: None,
+								location_in_module: None,
+                // remove everything after first space (?)
+								name: method.name.name.to_string(),
+								protected: None,
+								abstract_: None,
+								overrides: None,
+								static_: None,
+								returns: Some(jsii::OptionalValue {
+									optional: None,
+									type_: json!({ "primitive": "any" }),
+								}),
+								parameters: Some(
+									method
+										.parameters
+										.iter()
+										.map(|param| jsii::Parameter {
+											docs: None,
+											name: param.name.to_string(),
+											optional: None,
+											type_: json!({ "primitive": "any" }),
+											variadic: None,
+										})
+										.collect(),
+								),
+							})
+							.collect(),
+					),
+				};
+				jsii_types.insert(name.name.clone(), serde_json::to_value(manifest).unwrap());
+			}
+			Statement::Struct { extends, members, name } => {
+				let manifest = jsii::ClassType {
+					abstract_: Some(false),
+					base: match extends.len() {
+						0 => None,
+						1 => Some(extends[0].name.clone()),
+						_ => panic!("multi inheritance not supported yet"),
+					},
+					assembly: "wing".to_string(),
+					docs: None,
+					fqn: format!("wing.{}", name.name),
+					initializer: None,
+					interfaces: None,
+					kind: "class".to_string(),
+					location_in_module: None,
+					name: name.name.clone(),
+					namespace: None,
+					symbol_id: None,
+					methods: None,
+					properties: Some(
+						members
+							.iter()
+							.map(|member| jsii::Property {
+								abstract_: None,
+								docs: None,
+								immutable: Some(true),
+								location_in_module: None,
+								name: member.name.name.clone(),
+								optional: None,
+								overrides: None,
+								protected: None,
+								const_: None,
+								static_: None,
+								type_: json!({
+									"primitive": "any"
+								}),
+							})
+							.collect(),
+					),
+				};
+				jsii_types.insert(name.name.clone(), serde_json::to_value(manifest).unwrap());
+			}
+			_ => {}
+		}
+	}
+	let assembly = jsii::Assembly {
+		name: "wing".to_string(),
+		version: "0.1.0".to_string(),
+		description: "description".to_string(),
+		homepage: "homepage".to_string(),
+		license: "MIT".to_string(),
+		repository: jsii::AssemblyRepository {
+			directory: None,
+			type_: "git".to_string(),
+			url: "#blank".to_string(),
+		},
+		author: jsii::Person {
+			email: None,
+			name: "wingc".to_string(),
+			organization: None,
+			url: None,
+			roles: vec![],
+		},
+		fingerprint: "fingerprint".to_string(),
+		jsii_version: "3.20.120".to_string(),
+		schema: "jsii/0.10.0".to_string(),
+		targets: None,
+		types: Some(jsii_types),
+		bin: None,
+		bundled: None,
+		contributors: None,
+		dependencies: None,
+		dependency_closure: None,
+		docs: None,
+		keywords: None,
+		metadata: None,
+		readme: None,
+		submodules: None,
+	};
+	return serde_json::to_string_pretty(&assembly).unwrap();
+}

libs/wingc/src/lib.rs

@@ -1,8 +1,10 @@
+use crate::parser::bring;
 use ast::Scope;
 use diagnostic::Diagnostics;
 
 use crate::parser::Parser;
 use std::cell::RefCell;
+use std::collections::HashSet;
 use std::fs;
 use std::path::PathBuf;
 
@@ -15,59 +17,23 @@ pub mod ast;
 pub mod capture;
 pub mod diagnostic;
 pub mod jsify;
+pub mod jsiiify;
 pub mod parser;
 pub mod type_check;
 
-pub fn parse(source_file: &str) -> Scope {
-	let language = tree_sitter_wing::language();
-	let mut parser = tree_sitter::Parser::new();
-	parser.set_language(language).unwrap();
-
-	let source = match fs::read(&source_file) {
-		Ok(source) => source,
-		Err(err) => {
-			panic!("Error reading source file: {}: {:?}", &source_file, err);
-		}
-	};
-
-	let tree = match parser.parse(&source[..], None) {
-		Some(tree) => tree,
-		None => {
-			println!("Failed parsing source file: {}", source_file);
-			std::process::exit(1);
-		}
-	};
-
-	let wing_parser = Parser {
-		source: &source[..],
-		source_name: source_file.to_string(),
-		diagnostics: RefCell::new(Diagnostics::new()),
-	};
-
-	let scope = wing_parser.wingit(&tree.root_node());
-
-	for diagnostic in wing_parser.diagnostics.borrow().iter() {
-		println!("{}", diagnostic);
-	}
-
-	if wing_parser.diagnostics.borrow().len() > 0 {
-		std::process::exit(1);
-	}
-
-	scope
-}
-
 pub fn type_check(scope: &mut Scope, types: &mut Types) {
 	scope.set_env(TypeEnv::new(None, None, false, Flight::Pre));
 	let mut tc = TypeChecker::new(types);
 	tc.type_check_scope(scope);
 }
 
 pub fn compile(source_file: &str, out_dir: Option<&str>) -> String {
+	// create a new hashmap to manage imports
+	let mut imports = HashSet::new();
 	// Create universal types collection (need to keep this alive during entire compilation)
 	let mut types = Types::new();
 	// Build our AST
-	let mut scope = parse(source_file);
+	let mut scope = bring::bring(source_file, None, &mut imports).unwrap();
 	// Type check everything and build typed symbol environment
 	type_check(&mut scope, &mut types);
 	// Analyze inflight captures
@@ -81,6 +47,10 @@ pub fn compile(source_file: &str, out_dir: Option<&str>) -> String {
 	let intermediate_file = out_dir.join("intermediate.js");
 	fs::write(&intermediate_file, &intermediate_js).expect("Write intermediate JS to disk");
 
+	let jsii_manifest = jsiiify::jsiiify(&scope, &types);
+	let jsii_manifest_file = out_dir.join(".jsii");
+	fs::write(&jsii_manifest_file, &jsii_manifest).expect("Write JSII manifest to disk");
+
 	return intermediate_js;
 }