From 90aa05b4dbe1f3933e55d819f10b90fae8857cd1 Mon Sep 17 00:00:00 2001
From: Shimenkov Mikhail <shimenkov.mikhail@huawei-partners.com>
Date: Mon, 28 Apr 2025 17:07:55 +0300
Subject: [PATCH] Fix 'as' expression: substituted them with corresponging
 methods

Signed-off-by: Shimenkov Mikhail <shimenkov.mikhail@huawei-partners.com>
---
 .../src/as-expression-transformer.ts          | 80 +++++++++++++++++++
 .../compiler-plugin/src/koala-transformer.ts  |  5 +-
 2 files changed, 84 insertions(+), 1 deletion(-)
 create mode 100644 incremental/compiler-plugin/src/as-expression-transformer.ts

diff --git a/incremental/compiler-plugin/src/as-expression-transformer.ts b/incremental/compiler-plugin/src/as-expression-transformer.ts
new file mode 100644
index 000000000..87cefeac6
--- /dev/null
+++ b/incremental/compiler-plugin/src/as-expression-transformer.ts
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import * as ts from '@koalaui/ets-tsc';
+import { AbstractVisitor } from './AbstractVisitor';
+import { asString } from './util'
+
+export class AsExpressionTransformer extends AbstractVisitor {
+    constructor(
+        typeChecker: ts.TypeChecker,
+        ctx: ts.TransformationContext,
+    ) {
+        super(ctx)
+        this.typeMap = new Map<string, string>([
+            [ 'byte',       'Byte'  ],
+            [ 'short',      'Short' ],
+            [ 'int',        'Int'   ],
+            [ 'int32',      'Int'   ],
+            [ 'int64',      'Long'  ],
+            [ 'float',      'Float' ],
+            [ 'float32',    'Float' ],
+            [ 'float64',    'Double'],
+            [ 'double',     'Double']
+        ])
+        this.typeChecker = typeChecker
+    }
+
+    typeChecker : ts.TypeChecker
+    typeMap : Map<string, string>
+
+    transformAsExpression(node: ts.AsExpression): ts.Node {
+        if (!ts.isTypeReferenceNode(node.type)) {
+            return node;
+        }
+
+        let typeRef = node.type as ts.TypeReferenceNode
+        if (!ts.isIdentifier(typeRef.typeName)) {
+            return node;
+        }
+
+        let typeName = ts.idText(typeRef.typeName as ts.Identifier)
+        let expr = node.expression
+        let type = this.typeChecker.getTypeAtLocation(expr)
+
+        console.log("expr " + asString(expr) + ", type: " + this.typeChecker.typeToString(type) + ", isUnion? " + type.isUnion() + ", typeName: " + typeName)
+
+        if (!this.typeMap.has(typeName)) {
+            return node;
+        }
+
+        if (type.isUnion() || ts.Utils.isAnyType(type)) {
+            return node;
+        }
+
+        let obj = ts.factory.createParenthesizedExpression(expr)
+        let prop = ts.factory.createIdentifier("to" + this.typeMap.get(typeName))
+        let callee = ts.factory.createPropertyAccessExpression(obj, prop)
+        return ts.factory.createCallExpression(callee, undefined, undefined)
+    }
+
+    visitor(node: ts.Node): ts.Node {
+        let transformed = node
+        if (ts.isAsExpression(node)) {
+            transformed = this.visitEachChild(this.transformAsExpression(node))
+        }
+        return this.visitEachChild(transformed)
+    }
+}
diff --git a/incremental/compiler-plugin/src/koala-transformer.ts b/incremental/compiler-plugin/src/koala-transformer.ts
index 035fd7dad..67369842e 100644
--- a/incremental/compiler-plugin/src/koala-transformer.ts
+++ b/incremental/compiler-plugin/src/koala-transformer.ts
@@ -25,6 +25,7 @@ import { Tracer, TransformerOptions } from "./util"
 import { DumpVisitor } from './dump-visitor';
 import { ThisTransformer } from './this-transformer';
 import { ReturnTransformer } from './return-transformer';
+import { AsExpressionTransformer } from './as-expression-transformer';
 
 function getUnmemoizedPath(sourcePath: string, root: string, extension: string | undefined, unmemoizedDir?: string) {
     let relativePath = path.relative(root, sourcePath)
@@ -50,6 +51,7 @@ export function memoTransform(
     const thisTransformer = new ThisTransformer(tracer, typeChecker, sourceFile, rewrite.positionalIdTracker, rewrite.functionTable, ctx)
     const variableTransformer = new VariableTypeTransformer(tracer, typeChecker, sourceFile, rewrite, ctx)
     const returnTransformer = new ReturnTransformer(typeChecker, sourceFile, rewrite.functionTable, ctx)
+    const asExpressionTransformer = new AsExpressionTransformer(typeChecker, ctx)
 
     analysisVisitor.visitor(sourceFile)
     diagnosticsVisitor.visitor(sourceFile)
@@ -60,7 +62,8 @@ export function memoTransform(
     const transformedParameters = parameterTransformer.visitor(transformedFunctions)
     const transformedThis = thisTransformer.visitor(transformedParameters)
     const transformedReturn = returnTransformer.visitor(transformedThis)
-    return variableTransformer.visitor(transformedReturn) as ts.SourceFile
+    const transformedAsExpression = asExpressionTransformer.visitor(transformedReturn)
+    return variableTransformer.visitor(transformedAsExpression) as ts.SourceFile
 }
 
 export default function koala_transformer(program: ts.Program, pluginOptions: TransformerOptions, extras: ts.TransformerExtras) {
-- 
Gitee