wip

Author: lucacasonato

src/fast_check/mod.rs

@@ -709,7 +709,8 @@ fn transform_package(
         .module_from_specifier(&specifier)
         .unwrap_or_else(|| panic!("module not found: {}", specifier));
       if let Some(module_info) = module_info.esm() {
-        transform::transform(graph, module_info, &ranges, options).map(Some)
+        transform::transform(graph, module_info, root_symbol, &ranges, options)
+          .map(Some)
       } else {
         Ok(None) // nothing to transform
       }

src/fast_check/transform.rs

@@ -28,6 +28,7 @@ use indexmap::IndexMap;
 use crate::swc_helpers::FunctionKind;
 use crate::symbols::EsModuleInfo;
 use crate::symbols::ExpandoPropertyRef;
+use crate::symbols::RootSymbol;
 use crate::symbols::Symbol;
 use crate::ModuleGraph;
 use crate::ModuleInfo;
@@ -111,12 +112,14 @@ pub struct TransformOptions<'a> {
 pub fn transform(
   graph: &ModuleGraph,
   es_module_info: &EsModuleInfo,
+  root_symbol: &RootSymbol,
   public_ranges: &ModulePublicRanges,
   options: &TransformOptions,
 ) -> Result<FastCheckModule, Vec<FastCheckDiagnostic>> {
   let mut transformer = FastCheckTransformer::new(
     graph,
     es_module_info,
+    root_symbol,
     public_ranges,
     options.should_error_on_first_diagnostic,
   );
@@ -210,6 +213,7 @@ struct FastCheckTransformer<'a> {
   graph: &'a ModuleGraph,
   specifier: &'a ModuleSpecifier,
   es_module_info: &'a EsModuleInfo,
+  root_symbol: &'a RootSymbol<'a>,
   public_ranges: &'a ModulePublicRanges,
   parsed_source: &'a ParsedSource,
   should_error_on_first_diagnostic: bool,
@@ -221,13 +225,15 @@ impl<'a> FastCheckTransformer<'a> {
   pub fn new(
     graph: &'a ModuleGraph,
     es_module_info: &'a EsModuleInfo,
+    root_symbol: &'a RootSymbol<'a>,
     public_ranges: &'a ModulePublicRanges,
     should_error_on_first_diagnostic: bool,
   ) -> Self {
     Self {
       graph,
       specifier: es_module_info.specifier(),
       es_module_info,
+      root_symbol,
       public_ranges,
       parsed_source: es_module_info.source(),
       should_error_on_first_diagnostic,
@@ -1688,7 +1694,12 @@ impl<'a> FastCheckTransformer<'a> {
   }
 
   fn infer(&self) -> TypeInferrer<'_> {
-    TypeInferrer::new(self.specifier, self.parsed_source, self.es_module_info)
+    TypeInferrer::new(
+      self.specifier,
+      self.parsed_source,
+      self.es_module_info,
+      self.root_symbol,
+    )
   }
 
   fn maybe_transform_expr_if_leavable(

src/fast_check/type_infer.rs

@@ -17,6 +17,7 @@ use deno_ast::swc::ast::Prop;
 use deno_ast::swc::ast::PropOrSpread;
 use deno_ast::swc::ast::Str;
 use deno_ast::swc::ast::Tpl;
+use deno_ast::swc::ast::TsEntityName;
 use deno_ast::swc::ast::TsFnOrConstructorType;
 use deno_ast::swc::ast::TsFnParam;
 use deno_ast::swc::ast::TsFnType;
@@ -45,8 +46,14 @@ use deno_ast::SourceRangedForSpanned;
 
 use crate::swc_helpers::analyze_return_stmts_in_function_body;
 use crate::swc_helpers::FunctionKind;
+use crate::swc_helpers::ts_entity_name_to_parts;
 use crate::swc_helpers::ReturnStatementAnalysis;
+use crate::symbols::DefinitionPathNode;
 use crate::symbols::EsModuleInfo;
+use crate::symbols::ModuleInfoRef;
+use crate::symbols::ResolvedSymbolDepEntry;
+use crate::symbols::RootSymbol;
+use crate::symbols::SymbolNodeDep;
 use crate::FastCheckDiagnosticRange;
 
 use super::swc_helpers::is_call_expr_symbol_create;
@@ -494,18 +501,21 @@ pub struct TypeInferrer<'a> {
   specifier: &'a ModuleSpecifier,
   parsed_source: &'a ParsedSource,
   module_info: &'a EsModuleInfo,
+  root_symbol: &'a RootSymbol<'a>,
 }
 
 impl<'a> TypeInferrer<'a> {
   pub fn new(
     specifier: &'a ModuleSpecifier,
     parsed_source: &'a ParsedSource,
     module_info: &'a EsModuleInfo,
+    root_symbol: &'a RootSymbol<'a>,
   ) -> Self {
     Self {
       specifier,
       parsed_source,
       module_info,
+      root_symbol,
     }
   }
 
@@ -1125,20 +1135,38 @@ impl<'a> TypeInferrer<'a> {
     ty: &TsType,
   ) -> Result<(), ExprInferFailCause> {
     struct Visitor<'a> {
+      root_symbol: &'a RootSymbol<'a>,
       es_module_info: &'a EsModuleInfo,
       invalid_range: Option<SourceRange>,
     }
 
     impl Visit for Visitor<'_> {
-      fn visit_ident(&mut self, n: &Ident) {
-        if self.es_module_info.symbol_from_swc(&n.to_id()).is_none() {
-          self.invalid_range = Some(n.range());
+      fn visit_ts_entity_name(&mut self, n: &TsEntityName) {
+        let (id, parts) = ts_entity_name_to_parts(n);
+
+        let dep = SymbolNodeDep::QualifiedId(id, parts);
+
+        let entries = self
+          .root_symbol
+          .resolve_symbol_dep(ModuleInfoRef::Esm(self.es_module_info), &dep);
+
+        for entry in entries {
+          match entry {
+            ResolvedSymbolDepEntry::Path(DefinitionPathNode::Resolved(_))
+            | ResolvedSymbolDepEntry::ImportType(_) => {
+              // valid
+            }
+            ResolvedSymbolDepEntry::Path(DefinitionPathNode::Unresolved(_)) => {
+              self.invalid_range = Some(n.range());
+            }
+          }
         }
       }
     }
 
     let mut visitor = Visitor {
       es_module_info: self.module_info,
+      root_symbol: self.root_symbol,
       invalid_range: None,
     };
     ty.visit_with(&mut visitor);

src/swc_helpers.rs

@@ -3,8 +3,11 @@
 use std::ops::ControlFlow;
 
 use deno_ast::swc::ast::BlockStmt;
+use deno_ast::swc::ast::Id;
 use deno_ast::swc::ast::ReturnStmt;
 use deno_ast::swc::ast::Stmt;
+use deno_ast::swc::ast::TsEntityName;
+use deno_ast::swc::ast::TsQualifiedName;
 
 pub enum FunctionKind {
   /// function declarations, class method declarations (both class decl and class expr)
@@ -111,3 +114,32 @@ fn analyze_return_stmts_from_stmt(
     | Stmt::Empty(_) => ControlFlow::Continue(()),
   }
 }
+
+pub fn ts_entity_name_to_parts(
+  entity_name: &TsEntityName,
+) -> (Id, Vec<String>) {
+  match entity_name {
+    TsEntityName::TsQualifiedName(qualified_name) => {
+      ts_qualified_name_parts(qualified_name)
+    }
+    TsEntityName::Ident(ident) => (ident.to_id(), Vec::new()),
+  }
+}
+
+pub fn ts_qualified_name_parts(
+  mut qualified_name: &TsQualifiedName,
+) -> (Id, Vec<String>) {
+  let mut parts = Vec::new();
+  loop {
+    parts.push(qualified_name.right.sym.to_string());
+    match &qualified_name.left {
+      TsEntityName::TsQualifiedName(n) => {
+        qualified_name = n;
+      }
+      TsEntityName::Ident(n) => {
+        parts.reverse();
+        return (n.to_id(), parts);
+      }
+    }
+  }
+}

src/symbols/analyzer.rs

@@ -21,6 +21,7 @@ use indexmap::IndexMap;
 use indexmap::IndexSet;
 
 use crate::swc_helpers::analyze_return_stmts_in_function_body;
+use crate::swc_helpers::ts_entity_name_to_parts;
 use crate::swc_helpers::FunctionKind;
 use crate::swc_helpers::ReturnStatementAnalysis;
 use crate::JsModule;
@@ -39,7 +40,6 @@ use super::cross_module::DefinitionOrUnresolved;
 use super::cross_module::DefinitionPathNode;
 use super::cross_module::ModuleExports;
 use super::dep_analyzer::ResolveDepsMode;
-use super::swc_helpers::ts_entity_name_to_parts;
 use super::ResolvedSymbolDepEntry;
 use super::SymbolNodeDep;
 

src/symbols/dep_analyzer.rs

@@ -43,9 +43,9 @@ use deno_ast::swc::visit::Visit;
 use deno_ast::swc::visit::VisitWith;
 
 use crate::swc_helpers::analyze_return_stmts_in_function_body;
+use crate::swc_helpers::ts_entity_name_to_parts;
+use crate::swc_helpers::ts_qualified_name_parts;
 
-use super::swc_helpers::ts_entity_name_to_parts;
-use super::swc_helpers::ts_qualified_name_parts;
 use super::ExportDeclRef;
 use super::SymbolNodeRef;
 

src/symbols/mod.rs

@@ -35,4 +35,3 @@ mod analyzer;
 mod collections;
 mod cross_module;
 mod dep_analyzer;
-mod swc_helpers;

src/symbols/swc_helpers.rs

@@ -16,9 +16,6 @@
 //   return {} as typeof x;
 // };
 
-export const a = (b: string, c = {} as typeof b) => {
-};
-
 # output
 {
   "roots": [
@@ -27,7 +24,7 @@ export const a = (b: string, c = {} as typeof b) => {
   "modules": [
     {
       "kind": "esm",
-      "size": 144,
+      "size": 179,
       "mediaType": "TypeScript",
       "specifier": "file:///mod.ts"
     }
@@ -36,18 +33,15 @@ export const a = (b: string, c = {} as typeof b) => {
 }
 
 Fast check file:///mod.ts:
-  error[unknown-var-type]: unknown type for variable in the public API
-   --> /mod.ts:6:14
-    |
-  6 | export const a = (b: string, c = {} as typeof b): typeof b => {
-    |              ^ this variable's type could not be inferred because its initializer
-    |              - contains this arrow expression
-    |                              - which has this parameter, which is missing an explicit type annotation
-    |                                               - contains this reference to a local variable or type
-    |
-    = hint: add an explicit type annotation to the arrow expression parameter in the variable declaration initializer
-
-    info: all variables in the public API must have a known type
-    info: local variables or types can not be referenced in the public API because they are not visible at the top level of the module
-    docs: https://jsr.io/go/slow-type-unknown-var-type
-
+  {}
+  declare const Y: X;
+  interface X {
+    y: string;
+  }
+  export declare const a: (b: string, c?: typeof Y.z) => void;
+  --- DTS ---
+  declare const Y: X;
+  interface X {
+    y: string;
+  }
+  export declare const a: (b: string, c?: typeof Y.z) => void;