@abaplint/transpiler 2.12.23 → 2.12.24

package/build/src/expressions/new_object.js

@@ -6,6 +6,7 @@ const abaplint = require("@abaplint/core");
 const chunk_1 = require("../chunk");
 const type_name_or_infer_1 = require("./type_name_or_infer");
 const transpile_types_1 = require("../transpile_types");
+const types_1 = require("../types");
 class NewObjectTranspiler {
     transpile(node, traversal) {
         const ret = new chunk_1.Chunk();
@@ -18,8 +19,26 @@ class NewObjectTranspiler {
         if (parameters) {
             para = traversal.traverse(parameters).getCode();
         }
-        const type = new type_name_or_infer_1.TypeNameOrInfer().findType(typeNameOrInfer, traversal);
-        if (type instanceof abaplint.BasicTypes.ObjectReferenceType) {
+        let type = new type_name_or_infer_1.TypeNameOrInfer().findTypeOrUndefined(typeNameOrInfer, traversal);
+        if (type === undefined) {
+            const scope = traversal.findCurrentScopeByToken(node.getFirstToken());
+            try {
+                type = traversal.lookupType(typeNameOrInfer, scope);
+            }
+            catch {
+                // ignore
+            }
+        }
+        if (type === undefined) {
+            if (traversal.options?.unknownTypes === types_1.UnknownTypesEnum.runtimeError) {
+                ret.appendString(`(function() { throw new Error("Void type: ${typeNameOrInfer.concatTokens().toUpperCase()}") })()`);
+                return ret;
+            }
+            else {
+                throw new Error("NewObjectTranspiler, type not found: " + node.concatTokens() + ", " + traversal.getCurrentObject().getName() + " line " + node.getFirstToken().getStart().getRow());
+            }
+        }
+        else if (type instanceof abaplint.BasicTypes.ObjectReferenceType) {
             if (node.getChildren()[3].get() instanceof abaplint.Expressions.Source) {
                 // single default parameter
                 const scope = traversal.findCurrentScopeByToken(typeNameOrInfer.getFirstToken());
@@ -32,7 +51,13 @@ class NewObjectTranspiler {
             ret.appendString(transpile_types_1.TranspileTypes.toType(type) + ".set(await (new " + clas + "()).constructor_(" + para + "))");
         }
         else {
-            throw new Error("NewObjectTranspiler: only ObjectReferenceType currently handled, todo");
+            const source = node.findFirstExpression(abaplint.Expressions.Source);
+            if (source === undefined) {
+                throw new Error("NewObjectTranspiler: DataReference source not found");
+            }
+            const typeCode = transpile_types_1.TranspileTypes.toType(type);
+            const sourceCode = traversal.traverse(source).getCode();
+            ret.appendString("((() => {const r = new abap.types.DataReference(" + typeCode + "); r.assign(" + sourceCode + "); return r; })())");
         }
         return ret;
     }

package/build/src/expressions/type_name_or_infer.d.ts

@@ -4,5 +4,6 @@ import { Traversal } from "../traversal";
 import { Chunk } from "../chunk";
 export declare class TypeNameOrInfer implements IExpressionTranspiler {
     findType(node: Nodes.ExpressionNode, traversal: Traversal): AbstractType;
+    findTypeOrUndefined(node: Nodes.ExpressionNode, traversal: Traversal): AbstractType | undefined;
     transpile(node: Nodes.ExpressionNode, traversal: Traversal): Chunk;
 }

package/build/src/expressions/type_name_or_infer.js

@@ -12,6 +12,11 @@ class TypeNameOrInfer {
         }
         return type;
     }
+    findTypeOrUndefined(node, traversal) {
+        const scope = traversal.findCurrentScopeByToken(node.getFirstToken());
+        const type = traversal.lookupInferred(node, scope);
+        return type;
+    }
     transpile(node, traversal) {
         const type = this.findType(node, traversal);
         const ret = new chunk_1.Chunk();

package/build/src/traversal.js

@@ -595,7 +595,8 @@ this.INTERNAL_ID = abap.internalIdCounter++;\n`;
         if (scope === undefined) {
             return undefined;
         }
-        else if (!(node.get() instanceof abaplint.Expressions.TypeName)) {
+        else if (!(node.get() instanceof abaplint.Expressions.TypeName)
+            && !(node.get() instanceof abaplint.Expressions.TypeNameOrInfer)) {
             throw new Error("lookupType, node is not a TypeName, " + node.get());
         }
         const name = node.concatTokens().toLowerCase();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abaplint/transpiler",
-  "version": "2.12.23",
+  "version": "2.12.24",
   "description": "Transpiler",
   "main": "build/src/index.js",
   "typings": "build/src/index.d.ts",
@@ -29,7 +29,7 @@
   "author": "abaplint",
   "license": "MIT",
   "dependencies": {
-    "@abaplint/core": "^2.115.10",
+    "@abaplint/core": "^2.115.14",
     "source-map": "^0.7.6"
   },
   "devDependencies": {