Fix a bug when adding default constructor to class

Author: cannorin

lib/Extensions.fs

@@ -126,6 +126,32 @@ type JSRecord<'TKey, 'TValue> =
   [<Emit("$1 in $0")>]
   abstract member hasKey: 'TKey -> bool
 
+module JSRecord =
+  [<Emit("{}")>]
+  let empty<'TKey, 'TValue> : JSRecord<'TKey, 'TValue> = jsNative
+
+type JSObj =
+  [<EmitIndexer>]
+  abstract member Item: string -> JSObj option with get
+  [<EmitIndexer>]
+  abstract member Item: string -> JSObj with set
+  [<Emit("Object.keys($0)")>]
+  abstract member keys: string[]
+  [<Emit("Object.values($0)")>]
+  abstract member values: JSObj[]
+  [<Emit("Object.entries($0)")>]
+  abstract member entries: (string * JSObj)[]
+  [<Emit("$1 in $0")>]
+  abstract member hasKey: string -> bool
+
+module JSObj =
+  [<Emit("{}")>]
+  let empty : JSObj = jsNative
+  [<Emit("$0")>]
+  let box _ : JSObj = jsNative
+  [<Emit("$0")>]
+  let unbox (_: JSObj) : 'a = jsNative
+
 module JS =
   [<Emit("typeof $0")>]
   let typeof (_: 'a) : string = jsNative

lib/Syntax.fs

@@ -68,7 +68,7 @@ with
     match yo with
     | :? Location as y -> true
     | _ -> false
-  override x.GetHashCode() = 0
+  override x.GetHashCode() = x.AsComparable.GetHashCode()
   interface System.IComparable with
     member x.CompareTo(yo) =
       match yo with

lib/Typer.fs

@@ -908,7 +908,8 @@ module Statement =
 
   let createDefinitionsMap (stmts: Statement list) : Trie<string, Definition list> =
     let add ns name x trie =
-      trie |> Trie.addOrUpdate (List.rev (name :: ns)) [x] List.append
+      let key = List.rev (name :: ns)
+      trie |> Trie.addOrUpdate key [x] List.append
     let rec go (ns: string list) trie s =
       match s with
       | Export _
@@ -1415,14 +1416,16 @@ let inferEnumCaseValue (stmts: Statement list) : Statement list =
           { c with value = v }, v
       Enum { e with cases = e.cases |> List.mapFold f None |> fst }
     | Module m -> Module { m with statements = m.statements |> List.map go }
+    | Global m -> Global { m with statements = m.statements |> List.map go }
     | s -> s
   stmts |> List.map go
 
 let rec mergeStatements (stmts: Statement list) =
-  let mutable result : Choice<Statement, Class ref, Module ref> list = []
+  let mutable result : Choice<Statement, Class ref, Module ref, Global ref> list = []
 
   let mutable intfMap = Map.empty
   let mutable nsMap = Map.empty
+  let mutable globalM = None
   let mutable otherStmtSet = Set.empty
   let mergeTypeParams tps1 tps2 =
     let rec go acc = function
@@ -1456,7 +1459,7 @@ let rec mergeStatements (stmts: Statement list) =
       | None ->
         let iref = ref i
         intfMap <- (intfMap |> Map.add i.name iref)
-        result <- Choice2Of3 iref :: result
+        result <- Choice2Of4 iref :: result
       | Some iref' ->
         let i' = iref'.Value
         assert (i.accessibility = i'.accessibility)
@@ -1474,25 +1477,38 @@ let rec mergeStatements (stmts: Statement list) =
       | None ->
         let nref = ref n
         nsMap <- (nsMap |> Map.add n.name nref)
-        result <- Choice3Of3 nref :: result
+        result <- Choice3Of4 nref :: result
       | Some nref' ->
         let n' = nref'.Value
         nref'.Value <-
           { n with
               loc = n.loc ++ n'.loc
               comments = n.comments @ n'.comments |> List.distinct
               statements = n'.statements @ n.statements }
+    | Global n ->
+      match globalM with
+      | None ->
+        let nref = ref n
+        globalM <- Some nref
+        result <- Choice4Of4 nref :: result
+      | Some nref ->
+        let n' = nref.Value
+        nref.Value <-
+          { n with
+              loc = n.loc ++ n'.loc
+              comments = n.comments @ n'.comments |> List.distinct
+              statements = n'.statements @ n.statements }
     | stmt ->
       if otherStmtSet |> Set.contains stmt |> not then
         otherStmtSet <- otherStmtSet |> Set.add stmt
-        result <- Choice1Of3 stmt :: result
+        result <- Choice1Of4 stmt :: result
   result
   |> List.rev
   |> List.map (function
-    | Choice1Of3 s -> s
-    | Choice2Of3 i -> Class i.Value
-    | Choice3Of3 n ->
-      Module { n.Value with statements = mergeStatements n.Value.statements }
+    | Choice1Of4 s -> s
+    | Choice2Of4 i -> Class i.Value
+    | Choice3Of4 n -> Module { n.Value with statements = mergeStatements n.Value.statements }
+    | Choice4Of4 n -> Global { n.Value with statements = mergeStatements n.Value.statements }
   )
 
 let mergeSources newFileName (srcs: SourceFile list) =
@@ -1527,7 +1543,7 @@ let addDefaultConstructorToClass (ctx: TyperContext<_, _>) (stmts: Statement lis
     else
       match m.TryGetValue(c.loc) with
       | true, (c, cs) -> c, cs
-      | false, _ ->
+      | _, _ ->
         let parentConstructors =
           let (|Dummy|) _ = []
           let rec picker = function
@@ -1563,9 +1579,9 @@ let addDefaultConstructorToClass (ctx: TyperContext<_, _>) (stmts: Statement lis
         (c, cs)
   let rec go stmts =
     stmts |> List.map (function
-      | Class c when not c.isInterface ->
-        Class (addConstructors c |> fst)
+      | Class c when not c.isInterface -> Class (addConstructors c |> fst)
       | Module m -> Module { m with statements = go m.statements }
+      | Global m -> Global { m with statements = go m.statements }
       | x -> x)
   go stmts
 
@@ -1629,6 +1645,7 @@ let introduceAdditionalInheritance (ctx: IContext<#TyperOptions>) (stmts: Statem
 
         Class { c with implements = List.ofSeq inherits |> List.distinct }
       | Module m -> Module { m with statements = go m.statements }
+      | Global m -> Global { m with statements = go m.statements }
       | x -> x
     )
   go stmts
@@ -1691,14 +1708,15 @@ let detectPatterns (stmts: Statement list) : Statement list =
           else Some (Class intf)
         else Some (Class intf)
       | Module m -> Some (Module { m with statements = go m.statements })
+      | Global m -> Global { m with statements = go m.statements } |> Some
       | x -> Some x
     )
   go stmts
 
 let replaceAliasToFunction (ctx: #IContext<#TyperOptions>) stmts =
   let rec go = function
-    | Module m ->
-      Module { m with statements = List.map go m.statements }
+    | Module m -> Module { m with statements = List.map go m.statements }
+    | Global m -> Global { m with statements = List.map go m.statements }
     | TypeAlias ta ->
       match ta.target with
       | Func (f, typrms, loc) ->
@@ -1852,6 +1870,7 @@ let mergeESLibDefinitions (srcs: SourceFile list) =
     let vo, s = map None s.loc s
     match s with
     | Module m -> Module { m with statements = List.map mapStmt m.statements }
+    | Global m -> Global { m with statements = List.map mapStmt m.statements }
     | Enum e -> Enum { e with cases = e.cases |> List.map (fun c -> map vo c.loc c |> snd) }
     | Class c -> Class { c with members = c.members |> List.map (fun (a, m) -> map vo a.loc a |> snd, m) }
     | _ -> s

src/Targets/ParserTest.fs

@@ -3,6 +3,7 @@ module Targets.ParserTest
 open Ts2Ml
 open Syntax
 open Target
+open DataTypes
 
 type Options =
   inherit GlobalOptions
@@ -44,12 +45,15 @@ let private run (input: Input) (baseCtx: IContext<Options>) =
   baseCtx.options.replaceAliasToFunction <- true
   baseCtx.options.replaceNewableFunction <- true
   baseCtx.options.replaceRankNFunction <- true
+  baseCtx.options.inheritArraylike <- true
+  baseCtx.options.inheritIterable <- true
+  baseCtx.options.inheritPromiselike <- true
 
-  let srcs =
+  let ctx, srcs =
     if baseCtx.options.typing then
-      Typer.runAll input.sources baseCtx |> snd
+      Typer.runAll input.sources baseCtx
     else
-      input.sources
+      Typer.createRootContext input.sources baseCtx, input.sources
   let moduleName =
     JsHelper.deriveModuleName input.info (srcs |> List.map (fun src -> src.fileName))
   printfn "package info: %A" (JS.stringify input.info)
@@ -58,12 +62,27 @@ let private run (input: Input) (baseCtx: IContext<Options>) =
   match baseCtx.options.dumpAst with
   | None -> ()
   | Some output ->
-    let o = [|
+    let sources = [|
       for src in input.sources do
         yield
           {| file = src.fileName;
              statements = src.statements |> List.toArray |}
     |]
+    let info = [|
+      for KeyValue(src, info) in ctx.info do
+        let trie = JSObj.empty
+        for key in info.definitionsMap |> Trie.keys do
+          key |> List.fold (fun (o: JSObj) k ->
+            match o.[k] with
+            | Some o -> o
+            | None ->
+              let o' = JSObj.empty
+              o.[k] <- o'
+              o'
+          ) trie |> ignore
+        yield {| file = src; trie = trie |}
+    |]
+    let o = {| sources = sources; info = info |}
     Node.Api.fs.writeFileSync(output, stringify o)
 
 let target =