diff --git a/adl/adl.work.json b/adl/adl.work.json index 29ea20c2..5f291352 100644 --- a/adl/adl.work.json +++ b/adl/adl.work.json @@ -1,10 +1,9 @@ { "adlc": "0.0.0", - "use_embedded_sys_loader": true, "runtimes": [ { "ts_runtime": { - "outputDir": "../generated/typescript/tests" + "output_dir": "../generated/typescript/tests" } } ], @@ -32,11 +31,11 @@ "ts_opts": { "npm_pkg_name": "@adl-lang/protoclient", "runtime_opts": { - "packageRef": "@adl-lang/runtime" + "package_ref": {"name": "@adl-lang/runtime", "version": "1.0.0"} }, "outputs": { "gen": { - "outputDir": "../generated/typescript/tests/test31/src", + "output_dir": "../generated/typescript/tests/test31/src", "manifest": "../generated/typescript/tests/test31/.adl-manifest" } }, diff --git a/adl/adl.work2.json b/adl/adl.work2.json index 9bdc3702..7ba9f92e 100644 --- a/adl/adl.work2.json +++ b/adl/adl.work2.json @@ -4,7 +4,7 @@ "runtimes": [ { "ts_runtime": { - "outputDir": "../generated2/runtime", + "output_dir": "../generated2/runtime", "npm_pkg_name": "@adl-lang/runtime" } } @@ -14,16 +14,16 @@ "path": "./adlc", "ts_opts": { "npm_pkg_name": "@adl-lang/adlc", - "extraDevDependencies": { + "extra_dev_dependencies": { "tsconfig": "workspace:*", "typescript": "^4.9.3" }, "runtime_opts": { - "workspaceRef": "@adl-lang/runtime" + "workspace_ref": "@adl-lang/runtime" }, "outputs": { "gen": { - "outputDir": "../generated2/adlc", + "output_dir": "../generated2/adlc", "manifest": "../generated2/adlc/.adl-manifest" } }, @@ -34,16 +34,16 @@ "path": "./tests/test31/lib", "ts_opts": { "npm_pkg_name": "@adl-lang/common", - "extraDevDependencies": { + "extra_dev_dependencies": { "tsconfig": "workspace:*", "typescript": "^4.9.3" }, "runtime_opts": { - "workspaceRef": "@adl-lang/runtime" + "workspace_ref": "@adl-lang/runtime" }, "outputs": { "gen": { - "outputDir": "../generated2/common", + "output_dir": "../generated2/common", "manifest": "../generated2/common/.adl-manifest", "strip_first": false } @@ -55,16 +55,16 @@ "path": "./stdlib", "ts_opts": { "npm_pkg_name": "@adl-lang/sys", - "extraDevDependencies": { + "extra_dev_dependencies": { "tsconfig": "workspace:*", "typescript": "^4.9.3" }, "runtime_opts": { - "workspaceRef": "@adl-lang/runtime" + "workspace_ref": "@adl-lang/runtime" }, "outputs": { "gen": { - "outputDir": "../generated2/sys", + "output_dir": "../generated2/sys", "manifest": "../generated2/sys/.adl-manifest" } }, @@ -75,19 +75,19 @@ "path": "./tests/test31/proj", "ts_opts": { "npm_pkg_name": "@adl-lang/protoclient", - "extraDependencies": { + "extra_dependencies": { "base64-js": "^1.5.1" }, - "extraDevDependencies": { + "extra_dev_dependencies": { "tsconfig": "workspace:*", "typescript": "^4.9.3" }, "runtime_opts": { - "workspaceRef": "@adl-lang/runtime" + "workspace_ref": "@adl-lang/runtime" }, "outputs": { "gen": { - "outputDir": "../generated2/test31", + "output_dir": "../generated2/test31", "manifest": "../generated2/test31/.adl-manifest" } }, diff --git a/adl/adl.work3.json b/adl/adl.work3.json new file mode 100644 index 00000000..df3cb4da --- /dev/null +++ b/adl/adl.work3.json @@ -0,0 +1,51 @@ +{ + "adlc": "0.0.0", + "use_embedded_sys_loader": true, + "runtimes": [ + ], + "use": [ + { + "path": "./adlc", + "ts_opts": { + "npm_pkg_name": "@adl-lang/adlc" + } + }, + { + "path": "./tests/test31/lib", + "ts_opts": { + "npm_pkg_name": "@adl-lang/common" + } + }, + { + "path": "./stdlib", + "ts_opts": { + "npm_pkg_name": "@adl-lang/sys" + } + }, + { + "path": "./tests/test31/proj", + "ts_opts": { + "npm_pkg_name": "@adl-lang/protoclient", + "generate_transitive": true, + "extra_dependencies": { + "base64-js": "^1.5.1" + }, + "extra_dev_dependencies": { + "tsconfig": "workspace:*", + "typescript": "^4.9.3" + }, + "runtime_opts": { + "generate": {} + }, + "outputs": { + "gen": { + "output_dir": "../generated3/test31", + "manifest": "../generated3/test31/.adl-manifest", + "strip_first": false + } + }, + "include_resolver": true + } + } + ] +} diff --git a/adl/adlc/adl.pkg.json b/adl/adlc/adl.pkg.json index 4f6d1cb6..d141760c 100644 --- a/adl/adlc/adl.pkg.json +++ b/adl/adlc/adl.pkg.json @@ -1,6 +1,6 @@ { "path" : "github.com/adl-lang/adl/adl/adlc", - "globalAlias": "adlc", + "global_alias": "adlc", "adlc": "0.0.0", "requires": [ { diff --git a/adl/adlc/adlc/packaging.adl b/adl/adlc/adlc/packaging.adl index 4a95fca2..4a506ce5 100644 --- a/adl/adlc/adlc/packaging.adl +++ b/adl/adlc/adlc/packaging.adl @@ -28,18 +28,49 @@ struct AdlWorkspace { String adlc; Vector use; Vector runtimes = []; - Bool use_embedded_sys_loader = true; -}; + Nullable embedded_sys_loader = { + "p_ref": { + "path": "", + "ts_opts": { + "npm_pkg_name": "@adl-lang/sys", + "npm_version": "1.0.0", + "extra_dependencies": { + "base64-js": "^1.5.1" + }, + "extra_dev_dependencies": { + "tsconfig": "workspace:*", + "typescript": "^4.9.3" + } + } + }, + "pkg": { + "path": "github.com/adl-lang/adl/adl/stdlib/sys", + "global_alias": "sys", + "adlc": "0.0.0" + } + }; +}; + +// struct EmbeddedSysLoaderOpt { +// AdlPackageRef p_ref; +// AdlPackage pkg; +// // String npm_pkg_name; +// // String npm_version = "1.0.0"; +// // TsStyle ts_style = "tsc"; +// // StringMap dependencies = {}; +// // StringMap devDependencies = {}; +// }; union RuntimeOpts { TsWriteRuntime ts_runtime; }; struct TsWriteRuntime { - String outputDir; + String output_dir; ReferenceableScopeOption referenceable = "local"; String npm_pkg_name = "@adl-lang/runtime"; TsStyle ts_style = "tsc"; + Bool strip_first = true; }; // key must be a path to a directory directly under the folder containing the `adl.work.json` file. @@ -55,10 +86,10 @@ struct AdlPackageRef { struct TypescriptGenOptions { String npm_pkg_name; String npm_version = "1.0.0"; - StringMap extraDependencies = {}; - StringMap extraDevDependencies = {}; + StringMap extra_dependencies = {}; + StringMap extra_dev_dependencies = {}; Nullable outputs = null; - TsRuntimeOpt runtime_opts = { "packageRef": {"name": "@adl-lang/runtime", "version": "^1.0.0"} }; + TsRuntimeOpt runtime_opts = { "package_ref": {"name": "@adl-lang/runtime", "version": "^1.0.0"} }; Bool generate_transitive = false; Bool include_resolver = false; TsStyle ts_style = "tsc"; @@ -80,8 +111,8 @@ union InjectAnnotation { }; union TsRuntimeOpt { - String workspaceRef; - NpmPackageRef packageRef; + String workspace_ref; + NpmPackageRef package_ref; TsGenRuntime generate; }; @@ -100,9 +131,11 @@ union OutputOpts { struct GenOutput { ReferenceableScopeOption referenceable = "local"; - String outputDir; + String output_dir; Nullable manifest = null; /// When creating the path for output ts files delete the first part of the module name + /// This needs to be false for "generate_transitive" and + /// packages like "common" where the module and directory at the top level named the same. Bool strip_first = true; }; @@ -126,7 +159,7 @@ union ReferenceableScopeOption { /// Expected to live in a file named `adl.pkg.json` struct AdlPackage { String path; - Nullable globalAlias = null; + Nullable global_alias = null; /// Version String adlc; Vector requires = []; @@ -171,7 +204,8 @@ struct NpmPackage { String version; StringMap scripts = {}; StringMap dependencies = {}; - StringMap devDependencies = {}; + @SerializedName "devDependencies" + StringMap dev_dependencies = {}; }; // union DependencySpec { diff --git a/adl/stdlib/adl.pkg.json b/adl/stdlib/adl.pkg.json index ab85eda3..d3118de6 100644 --- a/adl/stdlib/adl.pkg.json +++ b/adl/stdlib/adl.pkg.json @@ -1,5 +1,5 @@ { "path" : "github.com/adl-lang/adl/adl/stdlib/sys", - "globalAlias": "sys", + "global_alias": "sys", "adlc": "0.0.0" } \ No newline at end of file diff --git a/adl/tests/test31/lib/adl.pkg.json b/adl/tests/test31/lib/adl.pkg.json index cf6d5086..c6f51718 100644 --- a/adl/tests/test31/lib/adl.pkg.json +++ b/adl/tests/test31/lib/adl.pkg.json @@ -1,6 +1,6 @@ { "path" : "github.com/adl-lang/adl/adl/tests/test31/lib", - "globalAlias": "common", + "global_alias": "common", "adlc": "0.0.0", "requires": [ { diff --git a/adl/tests/test31/proj/adl.pkg.json b/adl/tests/test31/proj/adl.pkg.json index 81941247..e1337369 100644 --- a/adl/tests/test31/proj/adl.pkg.json +++ b/adl/tests/test31/proj/adl.pkg.json @@ -1,6 +1,6 @@ { "path": "github.com/adl-lang/adl/adl/tests/test31/proj", - "globalAlias": "protoclient", + "global_alias": "protoclient", "adlc": "0.0.0", "requires": [ { diff --git a/adl/tests/test31/proj/protoclient/protoapp/api.adl b/adl/tests/test31/proj/protoclient/protoapp/api.adl index 98984afb..966fe5f2 100644 --- a/adl/tests/test31/proj/protoclient/protoapp/api.adl +++ b/adl/tests/test31/proj/protoclient/protoapp/api.adl @@ -18,9 +18,15 @@ import protoclient.protoapp.db.AppUser; import protoclient.protoapp.db.AppUserId; import protoclient.protoapp.db.MessageId; +struct X { + +}; + /// The app API struct ApiRequests { - Map imamap; + X x; + // Vector y; + Map imamap; /// Login a user HttpPost>> with_prim = { "path": "/login", diff --git a/rust/compiler/src/adlgen/adlc/packaging.rs b/rust/compiler/src/adlgen/adlc/packaging.rs index c2663033..1816ad09 100644 --- a/rust/compiler/src/adlgen/adlc/packaging.rs +++ b/rust/compiler/src/adlgen/adlc/packaging.rs @@ -50,7 +50,7 @@ impl Payload2 { /** * Expected to live in a file named `adl.work.json` */ -#[derive(Clone,Debug,Deserialize,Eq,Hash,PartialEq,Serialize)] +#[derive(Clone,Debug,Deserialize,PartialEq,Serialize)] pub struct AdlWorkspace { pub adlc: String, @@ -60,8 +60,8 @@ pub struct AdlWorkspace { #[serde(default="AdlWorkspace::::def_runtimes")] pub runtimes: Vec, - #[serde(default="AdlWorkspace::::def_use_embedded_sys_loader")] - pub use_embedded_sys_loader: bool, + #[serde(default="AdlWorkspace::::def_embedded_sys_loader")] + pub embedded_sys_loader: Option, } impl AdlWorkspace { @@ -70,7 +70,7 @@ impl AdlWorkspace { adlc: adlc, r#use: r#use, runtimes: AdlWorkspace::::def_runtimes(), - use_embedded_sys_loader: AdlWorkspace::::def_use_embedded_sys_loader(), + embedded_sys_loader: AdlWorkspace::::def_embedded_sys_loader(), } } @@ -78,8 +78,8 @@ impl AdlWorkspace { vec![] } - pub fn def_use_embedded_sys_loader() -> bool { - true + pub fn def_embedded_sys_loader() -> Option { + Some(Payload1{p_ref : AdlPackageRef{path : "".to_string(), ts_opts : Some(TypescriptGenOptions{npm_pkg_name : "@adl-lang/sys".to_string(), npm_version : "1.0.0".to_string(), extra_dependencies : [("base64-js".to_string(), "^1.5.1".to_string())].iter().cloned().collect(), extra_dev_dependencies : [("tsconfig".to_string(), "workspace:*".to_string()), ("typescript".to_string(), "^4.9.3".to_string())].iter().cloned().collect(), outputs : None, runtime_opts : TsRuntimeOpt::PackageRef(NpmPackageRef{name : "@adl-lang/runtime".to_string(), version : "^1.0.0".to_string()}), generate_transitive : false, include_resolver : false, ts_style : TsStyle::Tsc, modules : ModuleSrc::All, capitalize_branch_names_in_types : true, capitalize_type_names : true, annotate : vec![]})}, pkg : AdlPackage{path : "github.com/adl-lang/adl/adl/stdlib/sys".to_string(), global_alias : Some("sys".to_string()), adlc : "0.0.0".to_string(), requires : vec![], excludes : vec![], replaces : vec![], retracts : vec![]}}) } } @@ -91,7 +91,6 @@ pub enum RuntimeOpts { #[derive(Clone,Debug,Deserialize,Eq,Hash,PartialEq,Serialize)] pub struct TsWriteRuntime { - #[serde(rename="outputDir")] pub output_dir: String, #[serde(default="TsWriteRuntime::def_referenceable")] @@ -102,6 +101,9 @@ pub struct TsWriteRuntime { #[serde(default="TsWriteRuntime::def_ts_style")] pub ts_style: TsStyle, + + #[serde(default="TsWriteRuntime::def_strip_first")] + pub strip_first: bool, } impl TsWriteRuntime { @@ -111,6 +113,7 @@ impl TsWriteRuntime { referenceable: TsWriteRuntime::def_referenceable(), npm_pkg_name: TsWriteRuntime::def_npm_pkg_name(), ts_style: TsWriteRuntime::def_ts_style(), + strip_first: TsWriteRuntime::def_strip_first(), } } @@ -125,6 +128,10 @@ impl TsWriteRuntime { pub fn def_ts_style() -> TsStyle { TsStyle::Tsc } + + pub fn def_strip_first() -> bool { + true + } } pub type AdlPackageRefs = Vec; @@ -158,11 +165,9 @@ pub struct TypescriptGenOptions { pub npm_version: String, #[serde(default="TypescriptGenOptions::def_extra_dependencies")] - #[serde(rename="extraDependencies")] pub extra_dependencies: std::collections::HashMap, #[serde(default="TypescriptGenOptions::def_extra_dev_dependencies")] - #[serde(rename="extraDevDependencies")] pub extra_dev_dependencies: std::collections::HashMap, #[serde(default="TypescriptGenOptions::def_outputs")] @@ -269,10 +274,10 @@ pub enum InjectAnnotation { #[derive(Clone,Debug,Deserialize,Eq,Hash,PartialEq,Serialize)] pub enum TsRuntimeOpt { - #[serde(rename="workspaceRef")] + #[serde(rename="workspace_ref")] WorkspaceRef(String), - #[serde(rename="packageRef")] + #[serde(rename="package_ref")] PackageRef(NpmPackageRef), #[serde(rename="generate")] @@ -301,7 +306,6 @@ pub struct GenOutput { #[serde(default="GenOutput::def_referenceable")] pub referenceable: ReferenceableScopeOption, - #[serde(rename="outputDir")] pub output_dir: String, #[serde(default="GenOutput::def_manifest")] @@ -309,6 +313,8 @@ pub struct GenOutput { /** * When creating the path for output ts files delete the first part of the module name + * This needs to be false for "generate_transitive" and + * packages like "common" where the module and directory at the top level named the same. */ #[serde(default="GenOutput::def_strip_first")] pub strip_first: bool, @@ -378,7 +384,6 @@ pub struct AdlPackage { pub path: String, #[serde(default="AdlPackage::def_global_alias")] - #[serde(rename="globalAlias")] pub global_alias: Option, /** diff --git a/rust/compiler/src/cli/rust/mod.rs b/rust/compiler/src/cli/rust/mod.rs index 768d966b..ef86fad8 100644 --- a/rust/compiler/src/cli/rust/mod.rs +++ b/rust/compiler/src/cli/rust/mod.rs @@ -23,7 +23,7 @@ pub fn rust(opts: &RustOpts) -> anyhow::Result<()> { Err(e) => return Err(anyhow!("Failed to load module {}: {:?}", m, e)), } } - let modules: Vec = resolver + let modules: Vec<&Module1> = resolver .get_module_names() .into_iter() .map(|mn| resolver.get_module(&mn).unwrap()) diff --git a/rust/compiler/src/cli/tsgen/generate.rs b/rust/compiler/src/cli/tsgen/generate.rs index 7364b751..a7ac7b64 100644 --- a/rust/compiler/src/cli/tsgen/generate.rs +++ b/rust/compiler/src/cli/tsgen/generate.rs @@ -372,7 +372,8 @@ impl TsGenVisitor<'_> { }; let npm_pkg = get_npm_pkg(self.module); let imp = self.map.entry(scoped_name.clone()).or_insert_with(|| { - let path = if npm_pkg2 != None && npm_pkg2 != npm_pkg { + let path = if !self.opts.generate_transitive && npm_pkg2 != None && npm_pkg2 != npm_pkg + { npm_pkg_import(npm_pkg2.unwrap(), scoped_name.module_name.clone()) } else { rel_import(&self.module.name, &scoped_name.module_name) diff --git a/rust/compiler/src/cli/tsgen/mod.rs b/rust/compiler/src/cli/tsgen/mod.rs index 5a8bc7b2..9482ed59 100644 --- a/rust/compiler/src/cli/tsgen/mod.rs +++ b/rust/compiler/src/cli/tsgen/mod.rs @@ -5,7 +5,7 @@ use regex::bytes::Regex; use std::collections::HashMap; use std::fs; use std::ops::Deref; -use std::path::{PathBuf, Path}; +use std::path::{Path, PathBuf}; use anyhow::anyhow; @@ -13,8 +13,8 @@ use genco::fmt::{self, Indentation}; use genco::prelude::*; use crate::adlgen::adlc::packaging::{ - AdlWorkspace, NpmPackageRef, Payload1, TsGenRuntime, TsRuntimeOpt, TsStyle, TsWriteRuntime, - TypescriptGenOptions, NpmPackage, + AdlWorkspace, NpmPackage, NpmPackageRef, Payload1, TsGenRuntime, TsRuntimeOpt, TsStyle, + TsWriteRuntime, TypescriptGenOptions, }; use crate::adlgen::sys::adlast2::Module1; use crate::adlgen::sys::adlast2::{self as adlast}; @@ -124,6 +124,7 @@ pub fn tsgen( let mut resolver = Resolver::new(loader); let module_names = get_modules(opts, pkg_root)?; + println!("module_names:{:?}", module_names); for m in &module_names { let r = resolver.add_module(m); match r { @@ -138,7 +139,7 @@ pub fn tsgen( let parent = outputdir.file_name().unwrap().to_str().unwrap().to_string(); println!("!!!'{}'", parent); - let modules: Vec = resolver + let modules: Vec<&Module1> = resolver .get_module_names() .into_iter() .map(|mn| resolver.get_module(&mn).unwrap()) @@ -160,6 +161,7 @@ pub fn tsgen( gen_resolver( tokens, opts.npm_pkg_name.clone(), + opts.generate_transitive, &opts.runtime_opts, &resolver, &modules, @@ -181,7 +183,7 @@ pub fn tsgen( } if let TsRuntimeOpt::Generate(_) = &opts.runtime_opts { - gen_runtime(&opts.ts_style, &mut writer)? + gen_runtime(strip_first, &opts.ts_style, &mut writer)? } Ok(()) @@ -210,55 +212,71 @@ pub fn gen_npm_package(pkg_path: String, wrk1: &AdlWorkspace) -> anyho let mut npm_package = NpmPackage::new(opts.npm_pkg_name.clone(), opts.npm_version.clone()); match &opts.runtime_opts { TsRuntimeOpt::WorkspaceRef(rt) => { - npm_package.dependencies.insert(rt.clone(), "workspace:*".to_string()); - }, + npm_package + .dependencies + .insert(rt.clone(), "workspace:*".to_string()); + } TsRuntimeOpt::PackageRef(rt) => { - npm_package.dependencies.insert(rt.name.clone(), rt.version.clone()); - }, - TsRuntimeOpt::Generate(_) => {}, + npm_package + .dependencies + .insert(rt.name.clone(), rt.version.clone()); + } + TsRuntimeOpt::Generate(_) => {} }; for d in &opts.extra_dependencies { npm_package.dependencies.insert(d.0.clone(), d.1.clone()); } for d in &opts.extra_dev_dependencies { - npm_package.dev_dependencies.insert(d.0.clone(), d.1.clone()); + npm_package + .dev_dependencies + .insert(d.0.clone(), d.1.clone()); } for r in payload.pkg.requires.iter() { match &r.r#ref { crate::adlgen::adlc::packaging::PkgRef::Path(p0) => { match wrk1.r#use.iter().find(|p| p.pkg.path == *p0) { - Some(p1) => { - match &p1.p_ref.ts_opts { - Some(ts_opts) => { - npm_package.dependencies.insert(ts_opts.npm_pkg_name.clone(), "workspace:*".to_string()); - }, - None => { - return Err(anyhow!("no ts_opts in workspace file for package '{}'", p1.p_ref.path)) - }, + Some(p1) => match &p1.p_ref.ts_opts { + Some(ts_opts) => { + npm_package + .dependencies + .insert(ts_opts.npm_pkg_name.clone(), "workspace:*".to_string()); + } + None => { + return Err(anyhow!( + "no ts_opts in workspace file for package '{}'", + p1.p_ref.path + )) } }, None => return Err(anyhow!("no package is workspace with path '{}'", p0)), } - }, + } crate::adlgen::adlc::packaging::PkgRef::Alias(a) => { - match wrk1.r#use.iter().find(|p| p.pkg.global_alias == Some(a.to_string())) { - Some(p1) => { - match &p1.p_ref.ts_opts { - Some(ts_opts) => { - npm_package.dependencies.insert(ts_opts.npm_pkg_name.clone(), "workspace:*".to_string()); - }, - None => { - return Err(anyhow!("no ts_opts in workspace file for package '{}'", p1.p_ref.path)) - }, + match wrk1 + .r#use + .iter() + .find(|p| p.pkg.global_alias == Some(a.to_string())) + { + Some(p1) => match &p1.p_ref.ts_opts { + Some(ts_opts) => { + npm_package + .dependencies + .insert(ts_opts.npm_pkg_name.clone(), "workspace:*".to_string()); + } + None => { + return Err(anyhow!( + "no ts_opts in workspace file for package '{}'", + p1.p_ref.path + )) } }, None => return Err(anyhow!("no package is workspace with alias '{}'", a)), } - }, + } }; - }; + } let content = serde_json::to_string_pretty(&npm_package)?; writer.write(Path::new("package.json"), content)?; @@ -321,7 +339,7 @@ fn gen_ts_module( fn path_from_module_name(strip_first: bool, mname: adlast::ModuleName) -> PathBuf { let mut path = PathBuf::new(); - for (i,el) in mname.split(".").enumerate() { + for (i, el) in mname.split(".").enumerate() { if i == 0 && strip_first { continue; } @@ -334,9 +352,10 @@ fn path_from_module_name(strip_first: bool, mname: adlast::ModuleName) -> PathBu fn gen_resolver( t: &mut Tokens, npm_pkg: String, + generate_transitive: bool, runtime_opts: &TsRuntimeOpt, resolver: &Resolver, - modules: &Vec, + modules: &Vec<&Module1>, ) -> anyhow::Result<()> { // TODO remote or local imports let mut m_imports = vec![]; @@ -348,7 +367,7 @@ fn gen_resolver( None }; - let path = if npm_pkg2 != None { + let path = if !generate_transitive && npm_pkg2 != None { let npm_pkg2 = npm_pkg2.unwrap(); if npm_pkg2 != npm_pkg { npm_pkg_import(npm_pkg2, m.name.clone()) @@ -404,11 +423,12 @@ fn gen_resolver( pub fn write_runtime(rt_opts: &TsWriteRuntime) -> anyhow::Result<()> { let mut writer = TreeWriter::new(PathBuf::from(&rt_opts.output_dir), None)?; - gen_runtime(&rt_opts.ts_style, &mut writer)?; + gen_runtime(rt_opts.strip_first, &rt_opts.ts_style, &mut writer)?; Ok(()) } fn gen_runtime( + strip_first: bool, // rt_gen_opts: &TsGenRuntime, ts_style: &TsStyle, writer: &mut TreeWriter, @@ -417,7 +437,9 @@ fn gen_runtime( let re2 = Regex::new(r"\$TSB64IMPORT").unwrap(); for rt in RUNTIME.iter() { let mut file_path = PathBuf::new(); - // file_path.push("./runtime"); + if !strip_first { + file_path.push("./runtime"); + } // file_path.push(&rt_gen_opts.runtime_dir); file_path.push(rt.0); let dir_path = file_path.parent().unwrap(); diff --git a/rust/compiler/src/cli/tsgen/tests.rs b/rust/compiler/src/cli/tsgen/tests.rs index 4e20b0ac..2f93e6f9 100644 --- a/rust/compiler/src/cli/tsgen/tests.rs +++ b/rust/compiler/src/cli/tsgen/tests.rs @@ -74,12 +74,16 @@ fn generate_ts_from_test_files() { } let modules = t.modules.clone(); let ts_opts = TypescriptGenOptions { - npm_pkg_name: None, + npm_pkg_name: "testing".to_string(), + npm_version: "0.0.0".to_string(), + extra_dependencies: TypescriptGenOptions::def_extra_dependencies(), + extra_dev_dependencies: TypescriptGenOptions::def_extra_dev_dependencies(), annotate: vec![], outputs: Some(crate::adlgen::adlc::packaging::OutputOpts::Gen(GenOutput { referenceable: ReferenceableScopeOption::Local, output_dir: outdir.clone(), manifest: Some(manifest), + strip_first: false, })), runtime_opts: TsRuntimeOpt::Generate(TsGenRuntime {}), generate_transitive: true, diff --git a/rust/compiler/src/cli/workspace.rs b/rust/compiler/src/cli/workspace.rs index 87a6be26..7fd48abb 100644 --- a/rust/compiler/src/cli/workspace.rs +++ b/rust/compiler/src/cli/workspace.rs @@ -1,3 +1,4 @@ +use std::collections::HashMap; use std::path::PathBuf; use std::{env, fs}; @@ -6,7 +7,7 @@ use anyhow::anyhow; use serde::Deserialize; use crate::adlgen::adlc::packaging::{ - AdlPackage, AdlWorkspace0, AdlWorkspace1, Payload1, + AdlPackage, AdlWorkspace0, AdlWorkspace1, Payload1 }; use crate::processing::loader::loader_from_workspace; @@ -39,6 +40,49 @@ pub(crate) fn workspace(opts: &super::GenOpts) -> Result<(), anyhow::Error> { Ok(()) } +fn tuple_str_to_map(arg: &[(&str, &str)]) -> HashMap { + arg.iter() + .map(|a| (String::from(a.0), String::from(a.1))) + .collect() +} + +// fn embedded_payload() -> Option { +// Some(Payload1 { +// p_ref: AdlPackageRef { +// path: "".to_string(), +// ts_opts: Some(TypescriptGenOptions { +// npm_pkg_name: "@adl-lang/sys".to_string(), +// npm_version: TypescriptGenOptions::def_npm_version(), +// extra_dependencies: tuple_str_to_map(&[("base64-js", "^1.5.1")]), +// extra_dev_dependencies: tuple_str_to_map(&[ +// ("tsconfig", "workspace:*"), +// ("typescript", "^4.9.3"), +// ]), +// outputs: TypescriptGenOptions::def_outputs(), +// runtime_opts: TypescriptGenOptions::def_runtime_opts(), +// generate_transitive: false, +// include_resolver: false, +// ts_style: TypescriptGenOptions::def_ts_style(), +// modules: TypescriptGenOptions::def_modules(), +// capitalize_branch_names_in_types: +// TypescriptGenOptions::def_capitalize_branch_names_in_types(), +// capitalize_type_names: TypescriptGenOptions::def_capitalize_type_names( +// ), +// annotate: TypescriptGenOptions::def_annotate(), +// }), +// }, +// pkg: AdlPackage { +// path: "github.com/adl-lang/adl/adl/stdlib/sys".to_string(), +// global_alias: Some("sys".to_string()), +// adlc: "0.0.0".to_string(), +// requires: vec![], +// excludes: vec![], +// replaces: vec![], +// retracts: vec![], +// }, +// }) +// } + fn collection_to_workspace( pkg_defs: Vec<(PkgDef, PathBuf, &str)>, ) -> Result<(PathBuf, AdlWorkspace1), anyhow::Error> { @@ -59,7 +103,7 @@ fn collection_to_workspace( adlc: wrk0.adlc.clone(), runtimes: wrk0.runtimes, r#use: vec![], - use_embedded_sys_loader: wrk0.use_embedded_sys_loader, + embedded_sys_loader: wrk0.embedded_sys_loader, }; for p in wrk0.r#use.iter() { let p_path = porw.1.join(&p.path).join("adl.pkg.json"); diff --git a/rust/compiler/src/processing/loader.rs b/rust/compiler/src/processing/loader.rs index 75c54d20..7dc643ed 100644 --- a/rust/compiler/src/processing/loader.rs +++ b/rust/compiler/src/processing/loader.rs @@ -6,19 +6,22 @@ use std::fs; use std::io::ErrorKind; use std::path::PathBuf; -use crate::adlgen::adlc::packaging::{ - AdlPackage, AdlPackageRef, AdlWorkspace1, Payload1, TypescriptGenOptions, -}; +use crate::adlgen::adlc::packaging::{ AdlWorkspace1, Payload1 }; use crate::adlgen::sys::adlast2::{self as adlast, Module0}; use crate::parser::{convert_error, raw_module}; use crate::processing::annotations::apply_explicit_annotations_and_serialized_name; -pub fn loader_from_workspace(root: PathBuf, workspace: AdlWorkspace1) -> Box { +pub fn loader_from_workspace( + root: PathBuf, + workspace: AdlWorkspace1, + // embedded_payload: Option, +) -> Box { Box::new(WorkspaceLoader { root, workspace, embedded: EmbeddedStdlibLoader {}, loaders: HashMap::new(), + // embedded_payload, }) } @@ -43,56 +46,18 @@ pub struct WorkspaceLoader { root: PathBuf, workspace: AdlWorkspace1, embedded: EmbeddedStdlibLoader, + // embedded_payload: Option, loaders: HashMap>, } -fn tuple_str_to_map(arg: &[(&str, &str)]) -> HashMap { - arg.iter() - .map(|a| (String::from(a.0), String::from(a.1))) - .collect() -} - impl AdlLoader for WorkspaceLoader { fn load( &mut self, module_name: &adlast::ModuleName, ) -> Result)>, anyhow::Error> { - if self.workspace.use_embedded_sys_loader { + if let Some(_) = &self.workspace.embedded_sys_loader { if let Some(mut module) = self.embedded.load(module_name)? { - module.1 = Some(Payload1 { - p_ref: AdlPackageRef { - path: "".to_string(), - ts_opts: Some(TypescriptGenOptions { - npm_pkg_name: "@adl-lang/sys".to_string(), - npm_version: TypescriptGenOptions::def_npm_version(), - extra_dependencies: tuple_str_to_map(&[("base64-js", "^1.5.1")]), - extra_dev_dependencies: tuple_str_to_map(&[ - ("tsconfig", "workspace:*"), - ("typescript", "^4.9.3"), - ]), - outputs: TypescriptGenOptions::def_outputs(), - runtime_opts: TypescriptGenOptions::def_runtime_opts(), - generate_transitive: false, - include_resolver: false, - ts_style: TypescriptGenOptions::def_ts_style(), - modules: TypescriptGenOptions::def_modules(), - capitalize_branch_names_in_types: - TypescriptGenOptions::def_capitalize_branch_names_in_types(), - capitalize_type_names: TypescriptGenOptions::def_capitalize_type_names( - ), - annotate: TypescriptGenOptions::def_annotate(), - }), - }, - pkg: AdlPackage { - path: "github.com/adl-lang/adl/adl/stdlib/sys".to_string(), - global_alias: Some("sys".to_string()), - adlc: "0.0.0".to_string(), - requires: vec![], - excludes: vec![], - replaces: vec![], - retracts: vec![], - }, - }); + module.1 = self.workspace.embedded_sys_loader.clone(); return Ok(Some(module)); } } @@ -118,24 +83,26 @@ impl AdlLoader for WorkspaceLoader { self.root.join(&pkg.p_ref.path), ))); let module = loader.load(module_name); - println!("--- {} {}", &name.clone(), module_name); match module { Ok(module) => { - if let Some(mut module2) = module.clone() { + if let Some((mut module1, _)) = module.clone() { // TODO annotate ADL so this is Boxed - module2.1 = Some(pkg.clone()); - // if let Some(ts_opts) = &pkg.p_ref.ts_opts { - // if let Some(npm_pkg) = &ts_opts.npm_pkg_name { - // module2.0.annotations.0.insert( - // adlast::ScopedName { - // module_name: "adlc.config.typescript".to_string(), - // name: "NpmPackage".to_string(), - // }, - // serde_json::json!(npm_pkg), - // ); - // } - // } - return Ok(Some(module2)); + // let payload = Some(pkg.clone()); + if let Some(ts_opts) = &pkg.p_ref.ts_opts { + let mn1 = "adlc.config.typescript".to_string(); + module1.annotations.0.insert( + adlast::ScopedName { + module_name: if *module_name == mn1 { + "".to_string() + } else { + mn1 + }, + name: "NpmPackage".to_string(), + }, + serde_json::json!(&ts_opts.npm_pkg_name), + ); + } + return Ok(Some((module1, Some(pkg.clone())))); } } Err(_) => return module, diff --git a/rust/compiler/src/processing/resolver.rs b/rust/compiler/src/processing/resolver.rs index 636e9d87..b6f1390b 100644 --- a/rust/compiler/src/processing/resolver.rs +++ b/rust/compiler/src/processing/resolver.rs @@ -23,24 +23,13 @@ pub struct Resolver { modules: HashMap, } +#[derive(Debug)] pub struct ResolvedModule { module1: Module1, - payload1: Option, + _payload1: Option, decls: HashMap, } -fn insert_annotation(m: Module1, sn: adlast::ScopedName, jv: serde_json::Value) -> Module1 { - let mut ann = m.annotations.0.clone(); - ann.insert(sn, jv); - Module1 { - annotations: Map(ann), - ..m - // name: m.name.clone(), - // imports: m.imports.clone(), - // decls: m.decls.clone(), - } -} - impl Resolver { pub fn new(loader: Box) -> Self { Self { @@ -59,26 +48,11 @@ impl Resolver { } pub fn get_rmodule(&self, module_name: &ModuleName) -> Option<&ResolvedModule> { - let rmodule = self.modules.get(module_name); - rmodule + self.modules.get(module_name) } - pub fn get_module(&self, module_name: &ModuleName) -> Option { - self.modules.get(module_name).map(|rm| { - if let Some(payload) = &rm.payload1 { - if let Some(ts_opts) = &payload.p_ref.ts_opts { - // if let Some(npm_pkg) = &ts_opts.npm_pkg_name { - let sn = adlast::ScopedName { - module_name: "adlc.config.typescript".to_string(), - name: "NpmPackage".to_string(), - }; - let jv = serde_json::json!(&ts_opts.npm_pkg_name); - return insert_annotation(rm.module1.clone(), sn, jv); - // } - } - } - return rm.module1.clone(); - }) + pub fn get_module(&self, module_name: &ModuleName) -> Option<&Module1> { + self.modules.get(module_name).map(|rm| &rm.module1) } pub fn get_decl(&self, scoped_name: &adlast::ScopedName) -> Option<&Decl1> { @@ -98,7 +72,7 @@ impl Resolver { } if in_progress.contains(module_name) { - return Err(anyhow!("Circular reference loop including {}", module_name)); + return Err(anyhow!("Circular reference loop including module_name: '{}' in_progress: {:?}", module_name, in_progress)); } in_progress.insert(module_name.clone()); @@ -134,7 +108,7 @@ impl Resolver { let rmodule = ResolvedModule { module1, - payload1: module0.1, + _payload1: module0.1, decls, }; self.modules.insert(module_name.clone(), rmodule); @@ -145,7 +119,9 @@ impl Resolver { } fn add_default_imports(&self, module: &mut Module0) { - let default_imports = vec!["sys.annotations"]; + // sys.annotations does not need to be in default imports since Doc and SerializedName are processed in a way that does not require it. + // let default_imports = vec!["sys.annotations"]; + let default_imports: Vec<&str> = vec![]; for din in default_imports { let di = adlast::Import::ModuleName(din.to_owned()); if module.name != din && !module.imports.contains(&di) { @@ -229,8 +205,8 @@ fn resolve_decl( Ok(decl) } -fn resolve_struct( - ctx0: &mut ResolveCtx<'_>, +fn resolve_struct<'a>( + ctx0: &mut ResolveCtx<'a>, struct0: &adlast::Struct, ) -> Result> { let ctx = with_type_params(ctx0, &struct0.type_params);