Sourcemap: refine source mappings

nois-lang · Mar 19, 2024 · 4224ca8 · 4224ca8
1 parent 76c3d7e
commit 4224ca8
Show file tree

Hide file tree

Showing 4 changed files with 19 additions and 15 deletions.
diff --git a/src/codegen/js/expr.ts b/src/codegen/js/expr.ts
@@ -54,7 +54,10 @@ export const emitUnaryExpr = (unaryExpr: UnaryExpr, module: Module, ctx: Context
             const callerEmit = call.impl ? jsRelName(call.impl) : `${lOp.resultVar}.${relTypeName(methodDef.rel)}`
             const callEmit = jsVariable(resultVar, emitToken(`${callerEmit}().${methodName}(${argsEmit})`))
             return {
-                emit: emitTree([lOp.emit, upcastEmit, emitTree(jsArgs.map(a => a.emit)), callEmit]),
+                emit: emitTree(
+                    [lOp.emit, upcastEmit, emitTree(jsArgs.map(a => a.emit)), callEmit],
+                    mCall.name.parseNode
+                ),
                 resultVar
             }
         }
@@ -81,24 +84,25 @@ export const emitUnaryExpr = (unaryExpr: UnaryExpr, module: Module, ctx: Context
             const jsArgs = [...args, ...genericTypes]
             const upcastEmit = unaryExpr.upcasts ? emitUpcasts(resultVar, unaryExpr.upcasts) : undefined
             const variantDef = call.variantDef
+            const parseNode = unaryExpr.operand.kind === 'identifier' ? unaryExpr.operand.parseNode : call.parseNode
             if (variantDef) {
                 const variantName = `${variantDef.typeDef.name.value}.${variantDef.variant.name.value}`
-                const call = jsVariable(
+                const callEmit = jsVariable(
                     resultVar,
                     emitToken(`${variantName}(${jsArgs.map(a => a.resultVar).join(',')})`)
                 )
                 return {
-                    emit: emitTree([...jsArgs.map(a => a.emit), call, upcastEmit]),
+                    emit: emitTree([...jsArgs.map(a => a.emit), callEmit, upcastEmit], parseNode),
                     resultVar
                 }
             } else {
                 const operand = emitOperand(unaryExpr.operand, module, ctx)
-                const call = jsVariable(
+                const callEmit = jsVariable(
                     resultVar,
-                    emitToken(`${operand.resultVar}(${jsArgs.map(a => a.resultVar).join(',')})`)
+                    emitToken(`${operand.resultVar}(${jsArgs.map(a => a.resultVar).join(',')})`, parseNode)
                 )
                 return {
-                    emit: emitTree([operand.emit, ...jsArgs.map(a => a.emit), call, upcastEmit]),
+                    emit: emitTree([operand.emit, ...jsArgs.map(a => a.emit), callEmit, upcastEmit]),
                     resultVar
                 }
             }

diff --git a/src/codegen/js/index.ts b/src/codegen/js/index.ts
@@ -26,7 +26,7 @@ export const emitModule = (module: Module, ctx: Context, mainFn?: string): EmitN
                   `try{${mainFn}();}catch(e){console.error(\`\${e.message}\${e.stack.split("\\n").slice(1).join("\\n")}\`);}`
               )
             : undefined
-    return emitTree([imports, statements, mainFnInvoke], module.parseNode)
+    return emitTree([imports, statements, mainFnInvoke])
 }
 
 export const emitImports = (module: Module, ctx: Context): EmitNode => {
@@ -65,7 +65,7 @@ const makeJsImport = (vid: VirtualIdentifier, importModule: Module, module: Modu
 
 export const emitUpcasts = (resultVar: string, upcasts: Map<string, Upcast>): EmitToken => {
     const args = [...upcasts.entries()].map(
-        ([k, v]) => `[${[...v.traits.entries()].map(([tk, tv]) => `[${jsString(tk)}, ${jsRelName(tv)}]`).join(',')}]`
+        ([, v]) => `[${[...v.traits.entries()].map(([tk, tv]) => `[${jsString(tk)}, ${jsRelName(tv)}]`).join(',')}]`
     )
     args.unshift(resultVar)
     return emitToken(`${resultVar}.upcast(${args.join(',')});`)

diff --git a/src/codegen/js/statement.ts b/src/codegen/js/statement.ts
@@ -43,11 +43,11 @@ export const emitFnDef = (fnDef: FnDef, module: Module, ctx: Context, asProperty
     const jsParams = emitIntersperse([...params, ...generics], ',')
     const block = emitBlock(fnDef.block, module, ctx, true)
     if (asProperty) {
-        return emitTree([emitToken(`${name}: function(`), jsParams, emitToken(')'), block], fnDef.parseNode)
+        return emitTree([emitToken(`${name}: function(`), jsParams, emitToken(')'), block], fnDef.name.parseNode)
     } else {
         return emitTree(
             [emitToken(`${fnDef.pub ? 'export ' : ''}function ${name}(`), jsParams, emitToken(')'), block],
-            fnDef.parseNode
+            fnDef.name.parseNode
         )
     }
 }
@@ -93,7 +93,7 @@ export const emitInstanceDef = (instanceDef: ImplDef | TraitDef, module: Module,
 export const emitTypeDef = (typeDef: TypeDef, module: Module, ctx: Context): EmitNode => {
     const name = typeDef.name.value
     const variants = typeDef.variants.map(v =>
-        emitTree([emitToken(`${v.name.value}:`), emitVariant(v, typeDef, module, ctx)], v.parseNode)
+        emitTree([emitToken(`${v.name.value}:`), emitVariant(v, typeDef, module, ctx)])
     )
     const items_ = emitIntersperse(variants, ',')
     const items = items_.nodes.length > 0 ? emitTree([emitToken('{'), items_, emitToken('}')]) : emitToken('{}')
@@ -102,7 +102,7 @@ export const emitTypeDef = (typeDef: TypeDef, module: Module, ctx: Context): Emi
 
 export const emitReturnStmt = (returnStmt: ReturnStmt, module: Module, ctx: Context): EmitNode => {
     const { emit: exprEmit, resultVar } = emitExpr(returnStmt.returnExpr, module, ctx)
-    return emitTree([exprEmit, emitToken(`return ${resultVar};`)], returnStmt.parseNode)
+    return emitTree([exprEmit, emitToken(`return ${resultVar};`)])
 }
 
 export const emitBreakStmt = (breakStmt: BreakStmt, module: Module, ctx: Context): EmitNode => {
@@ -130,7 +130,7 @@ export const emitBlockStatements = (
 
 export const emitBlock = (block: Block, module: Module, ctx: Context, resultVar?: boolean | string): EmitNode => {
     const statements = emitBlockStatements(block, module, ctx, resultVar)
-    return emitTree([emitToken('{'), ...statements, emitToken('}')], block.parseNode)
+    return emitTree([emitToken('{'), ...statements, emitToken('}')])
 }
 
 export const emitVariant = (v: Variant, typeDef: TypeDef, module: Module, ctx: Context): EmitNode => {
@@ -154,5 +154,5 @@ export const emitVariant = (v: Variant, typeDef: TypeDef, module: Module, ctx: C
 export const emitUpcastFn = (v: Variant, typeDef: TypeDef, module: Module, ctx: Context): EmitNode => {
     const params = ['value', 'Self', ...typeDef.generics.map(g => g.name.value)]
     const selfG = 'for(const [trait,impl] of Self){value[trait]=impl;}'
-    return emitTree([emitToken(`function(${params.join(',')}) {`), emitToken(selfG), emitToken('}')], v.parseNode)
+    return emitTree([emitToken(`function(${params.join(',')}) {`), emitToken(selfG), emitToken('}')])
 }
diff --git a/src/index.ts b/src/index.ts
@@ -204,7 +204,7 @@ if (config.emit) {
             const { emit, map } = foldEmitTree(emitNode)
 
             const sourceMapLink = `//# sourceMappingURL=${moduleOutPath.name}.js.map`
-            const js = [emit, native, sourceMapLink].filter(m => m.length > 0).join('\n\n')
+            const js = [emit, native, sourceMapLink].filter(m => m.length > 0).join('\n')
             const jsPath = join(moduleOutPath.dir, moduleOutPath.name) + '.js'
             writeFile(jsPath, js).then(() => console.info(`emit: js           ${jsPath} [${js.length}B]`))