From 856a80cc3650690183bb276d07adcb2042e56536 Mon Sep 17 00:00:00 2001 From: Mikhail Velikanov Date: Thu, 11 Aug 2022 14:27:38 +0300 Subject: [PATCH 1/5] By default, don't terminate translation on Java syntax or semantic errors, simply report them. Also don't check syntax of resulting STS code by default. Do both of the above if in strict mode (-s or -strict command line switch). Do STS syntax check after translation if explcitly requested (-T or -check-sts-syntax command line switch). Also extended metrics computation to cover translation of types. Change-Id: I9991f07ef6830c2615876576614627c69ca45034 Signed-off-by: Mikhail Velikanov --- .../com/ohos/migrator/AbstractTranspiler.java | 11 ++---- migrator/src/com/ohos/migrator/Main.java | 14 +++++--- .../src/com/ohos/migrator/TestRunner.java | 2 +- .../com/ohos/migrator/java/JavaParser.java | 27 ++++++++++++--- .../migrator/java/JavaParserException.java | 8 ++--- .../ohos/migrator/java/JavaTransformer.java | 34 +++++++++++++++++-- 6 files changed, 69 insertions(+), 27 deletions(-) diff --git a/migrator/src/com/ohos/migrator/AbstractTranspiler.java b/migrator/src/com/ohos/migrator/AbstractTranspiler.java index f727ac86d..196df0c8a 100644 --- a/migrator/src/com/ohos/migrator/AbstractTranspiler.java +++ b/migrator/src/com/ohos/migrator/AbstractTranspiler.java @@ -36,14 +36,7 @@ public abstract class AbstractTranspiler implements Transpiler { protected List libFiles; protected List outFiles; protected List errorList; - private String outDir = null; - - protected boolean strictMode = false; - public void setStrictMode(boolean mode) { - strictMode = mode; - } - public AbstractTranspiler(List src, List libs, String outDir) { sourceFiles = src; libFiles = libs; @@ -67,7 +60,7 @@ public abstract class AbstractTranspiler implements Transpiler { } catch (TranspileException e) { errorList.add(e); transpileResult = ResultCode.majorValue(e.getResult(), transpileResult); - if (strictMode) return transpileResult; + if (Main.isStrictMode()) return transpileResult; } catch (Exception e) { StringBuilder sb = new StringBuilder(e.getClass().getName()); @@ -78,7 +71,7 @@ public abstract class AbstractTranspiler implements Transpiler { errorList.add(new TranspileException(ResultCode.InputError, sb.toString())); transpileResult = ResultCode.majorValue(ResultCode.InputError, transpileResult); - if (strictMode) return transpileResult; + if (Main.isStrictMode()) return transpileResult; } } diff --git a/migrator/src/com/ohos/migrator/Main.java b/migrator/src/com/ohos/migrator/Main.java index 6cad99455..4f8e16954 100644 --- a/migrator/src/com/ohos/migrator/Main.java +++ b/migrator/src/com/ohos/migrator/Main.java @@ -65,6 +65,9 @@ public class Main { public static boolean hasErrors() { return !errorList.isEmpty(); } + public static void addError(ResultCode code, String message) { + errorList.add(new TranspileException(code, message)); + } public static void main(String[] args) { final Options options = new Options(); @@ -74,7 +77,7 @@ public class Main { options.addOption(new Option("o","outdir",true,"Specify where to place generated source files")); options.addOption(new Option("nowarn","nowarn",false,"Generate no warnings")); options.addOption(new Option("Werror","Werror",false,"Treate warnings as errors")); - options.addOption(new Option("strict","strict",false,"Terminate transpile process after first error occurs")); + options.addOption(new Option("s","strict",false,"Terminate transpile process after first error occurs")); options.addOption(new Option("l","libs",true, "List of libraries separate with commas")); options.addOption(new Option("T","check-sts-syntax",false,"Check syntactical correctness of StaticTS sources")); options.addOption(new Option("R", "conversion-rate", false, "Report conversion rate")); @@ -145,7 +148,7 @@ public class Main { } } - if (needStsSyntaxCheck) { + if (needStsSyntaxCheck && !stsSources.isEmpty()) { ResultCode code = checkSTSSyntax(stsSources); finish(code); } @@ -184,7 +187,6 @@ public class Main { System.out.println("Transpiling " + javaSources.size() + " Java files."); JavaTranspiler javaTranspiler = new JavaTranspiler(javaSources, jarLibs, outDir); - if(isStrictMode()) javaTranspiler.setStrictMode(true); resultCode = javaTranspiler.transpile(); outFiles.addAll(javaTranspiler.getOutFiles()); errorList.addAll(javaTranspiler.getErrorList()); @@ -214,7 +216,11 @@ public class Main { // Check syntax of all STS files produced. // NOTE: This is for development process only, probably to be removed afterwards. - resultCode = ResultCode.majorValue(checkSTSSyntax(outFiles), resultCode); + // NOTE: We now ignore Java syntax and semantic errors by default, + // so don't check STS syntax by default, either. + if (isStrictMode() || needStsSyntaxCheck) + resultCode = ResultCode.majorValue(checkSTSSyntax(outFiles), resultCode); + finish(resultCode); } catch (UnrecognizedOptionException e) { diff --git a/migrator/src/com/ohos/migrator/TestRunner.java b/migrator/src/com/ohos/migrator/TestRunner.java index 69e59aad6..2d0af0e7d 100644 --- a/migrator/src/com/ohos/migrator/TestRunner.java +++ b/migrator/src/com/ohos/migrator/TestRunner.java @@ -63,7 +63,7 @@ public class TestRunner { String testFilePath = new File(testDir, testFile).getPath(); System.out.println("Running test " + testFile); - String[] mainArgs = new String[] {"-verbose", "-o", testResultDir.getPath(), testFilePath}; + String[] mainArgs = new String[] {"-verbose", "-s", "-o", testResultDir.getPath(), testFilePath}; Main.runTests(mainArgs); File resultFile = new File(testResultDir, testFile + Main.STS_EXT); diff --git a/migrator/src/com/ohos/migrator/java/JavaParser.java b/migrator/src/com/ohos/migrator/java/JavaParser.java index 5ecb4efc2..f2cc113e4 100644 --- a/migrator/src/com/ohos/migrator/java/JavaParser.java +++ b/migrator/src/com/ohos/migrator/java/JavaParser.java @@ -16,6 +16,7 @@ package com.ohos.migrator.java; import com.ohos.migrator.Main; +import com.ohos.migrator.ResultCode; import com.ohos.migrator.util.FileUtils; import org.eclipse.jdt.core.JavaCore; import org.eclipse.jdt.core.compiler.IProblem; @@ -53,7 +54,7 @@ public class JavaParser { /** * Create a Java parser. * - * @param fileToParse Java source file to be parsed. + * @param sourceFile Java source file to be parsed. * @param sourceFiles List of Java source files whose paths will be used to configure * parser's 'sourcepaths' setting. * @param classpaths List of paths to jar files or directories with '.class' files. @@ -197,12 +198,28 @@ public class JavaParser { CompilationUnit cu = (CompilationUnit) parser.createAST(null); if (cu == null) throw new JavaParserException("unknown Java parsing error"); - // Problems contains both warnings and errors. Don't throw the exception when there are only warnings. - for (IProblem problems : cu.getProblems()) { - if (problems.isError()) - throw new JavaParserException(cu.getProblems()); + // In strict mode, terminate on syntax or semantic errors; + // otherwise, report them and continue. + for (IProblem problem : cu.getProblems()) { + if (problem.isError()) { + if (Main.isStrictMode()) + throw new JavaParserException(cu.getProblems()); + else + Main.addError(ResultCode.ParseError, buildErrorMessage(problem)); + } } return cu; } + + public static String buildErrorMessage(IProblem problem) { + StringBuilder sb = new StringBuilder(); + int lineNumber = problem.getSourceLineNumber(); + String fileName = String.valueOf(problem.getOriginatingFileName()); + + String pos = fileName + "(" + lineNumber + "): "; + sb.append(pos).append(problem.getMessage()); + + return sb.toString(); + } } diff --git a/migrator/src/com/ohos/migrator/java/JavaParserException.java b/migrator/src/com/ohos/migrator/java/JavaParserException.java index e0411fb27..8dad5a2bc 100644 --- a/migrator/src/com/ohos/migrator/java/JavaParserException.java +++ b/migrator/src/com/ohos/migrator/java/JavaParserException.java @@ -18,20 +18,18 @@ package com.ohos.migrator.java; import org.eclipse.jdt.core.compiler.IProblem; public class JavaParserException extends Exception { - private static String buildErrorMessage(IProblem[] parseProblems) { StringBuilder sb = new StringBuilder(); for (IProblem problem: parseProblems) { - String pos = new String(problem.getOriginatingFileName()) + "(" + problem.getSourceLineNumber() + "): "; - sb.append(pos + problem.getMessage()).append('\n'); + if (problem.isError()) + sb.append(JavaParser.buildErrorMessage(problem)).append("\n"); } + return sb.toString(); } - public JavaParserException(IProblem[] parseProblems) { this(buildErrorMessage(parseProblems)); } - public JavaParserException(String s) { super(s); } diff --git a/migrator/src/com/ohos/migrator/java/JavaTransformer.java b/migrator/src/com/ohos/migrator/java/JavaTransformer.java index 1f6c3a5d7..073edfa30 100644 --- a/migrator/src/com/ohos/migrator/java/JavaTransformer.java +++ b/migrator/src/com/ohos/migrator/java/JavaTransformer.java @@ -49,14 +49,16 @@ public class JavaTransformer extends ASTVisitor implements Transformer { private final String ENUM_TYPE_NAME = "ENUM_TYPE_NAME"; private final String ENUM_CONST_ORDINAL = "ENUM_CONST_ORDINAL"; + private static int countStmtTotal = 0; private static int countExprTotal = 0; - private static int countDeclTotal = 0; + private static int countTypeTotal = 0; private static int countExprTransformed = 0; private static int countStmtTransformed = 0; - private static int countDeclTransformed = 0; + private static int countTypeTransformed = 0; + public static double getTransformationRate() { double result = 0.; int normFactor = 0; @@ -73,6 +75,10 @@ public class JavaTransformer extends ASTVisitor implements Transformer { ++normFactor; result += countDeclTransformed / (double)countDeclTotal; } + if (countTypeTotal > 0) { + ++normFactor; + result += countTypeTransformed / (double)countTypeTotal; + } return (normFactor > 0) ? result / (double)normFactor : 0.; } @@ -159,8 +165,13 @@ public class JavaTransformer extends ASTVisitor implements Transformer { else if (node instanceof Statement) ++countStmtTotal; else if (node instanceof BodyDeclaration - || node instanceof VariableDeclaration) + || node instanceof VariableDeclaration + || node.getNodeType() == ASTNode.ANONYMOUS_CLASS_DECLARATION + || node.getNodeType() == ASTNode.IMPORT_DECLARATION + || node.getNodeType() == ASTNode.PACKAGE_DECLARATION) ++countDeclTotal; + else if (node instanceof Type) + ++countTypeTotal; } }); @@ -204,6 +215,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { popCurrent(); // PackageDeclarationContext + ++countDeclTransformed; return false; } @@ -642,6 +654,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { popCurrent(); // ImportStatementContext + ++countDeclTransformed; return false; } @@ -686,6 +699,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { if (needPrimaryType) popCurrent(); // PrimaryTypeContext + ++countTypeTransformed; return false; } @@ -706,6 +720,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { if (needPrimaryType) popCurrent(); // PrimaryTypeContext + ++countTypeTransformed; return false; } @@ -741,6 +756,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { stsTypeRef.addChild(stsTypeRefPart).setParent(stsTypeRef); if (needPrimaryType) popCurrent(); // PrimaryTypeContext + + ++countTypeTransformed; return false; } @@ -764,6 +781,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { if (needPrimaryType) popCurrent(); // PrimaryTypeContext + ++countTypeTransformed; return false; } @@ -804,6 +822,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { } if (needPrimaryType) popCurrent(); // PrimaryTypeContext + + ++countTypeTransformed; return false; } @@ -824,6 +844,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { } popCurrent(); // WildcardTypeContext + + ++countTypeTransformed; return false; } @@ -844,6 +866,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { popCurrent(); // ArrayTypeContext if (needPrimaryType) popCurrent(); // PrimaryTypeContext + + ++countTypeTransformed; return false; } @@ -868,6 +892,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { popCurrent(); // IntersectionTypeContext if (needPrimaryType) popCurrent(); // PrimaryTypeContext + + ++countTypeTransformed; return false; } @@ -2446,6 +2472,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { } popCurrent(); // ClassBodyContext + + ++countDeclTransformed; return false; } -- Gitee From d2c82f1fb88c4e6be2bd524467ad85770c877b3e Mon Sep 17 00:00:00 2001 From: Mikhail Velikanov Date: Thu, 11 Aug 2022 15:26:42 +0300 Subject: [PATCH 2/5] Minor fix to translation of type parameters to avoid ClassCastException. Change-Id: I30b3e01b8b58a6eaa5b6dc003ab67d94481ac62f Signed-off-by: Mikhail Velikanov --- migrator/src/com/ohos/migrator/java/JavaTransformer.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/migrator/src/com/ohos/migrator/java/JavaTransformer.java b/migrator/src/com/ohos/migrator/java/JavaTransformer.java index 073edfa30..439c87e43 100644 --- a/migrator/src/com/ohos/migrator/java/JavaTransformer.java +++ b/migrator/src/com/ohos/migrator/java/JavaTransformer.java @@ -1224,7 +1224,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { // STS tree: // typeParameters: LessThan typeParameterList? MoreThan // typeParameterList: typeParameter (Comma typeParameter)* - private void createStsTypeParameters(List javaTypeParameters) { + private void createStsTypeParameters(List javaTypeParameters) { assert(javaTypeParameters != null); if (!javaTypeParameters.isEmpty()) { @@ -1234,8 +1234,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { // typeParameterList: typeParameter (Comma typeParameter)* pushCurrent(new TypeParameterListContext(stsCurrent, 0)); - for (Type javaType : javaTypeParameters) { - javaType.accept(this); + for (TypeParameter javaTypeParam : javaTypeParameters) { + javaTypeParam.accept(this); // Note: TerminalToken (Comma) is not added to the tree. Check if it works OK. } -- Gitee From cc5704b0f5381c6752a263234b728e31edfb5456 Mon Sep 17 00:00:00 2001 From: Mikhail Velikanov Date: Thu, 11 Aug 2022 15:50:48 +0300 Subject: [PATCH 3/5] Minor fix to translation of method declaration modifiers. Also updates to tests to account for the changes above. Change-Id: I88cf3c6e2445d1f2527f7bb8e7b984cb0ef62cfe Signed-off-by: Mikhail Velikanov --- .../src/com/ohos/migrator/java/JavaTransformer.java | 11 ++++++----- migrator/test/java/intersection-type.java.sts | 4 ++-- migrator/test/java/method_invocation.java.sts | 8 ++++---- 3 files changed, 12 insertions(+), 11 deletions(-) diff --git a/migrator/src/com/ohos/migrator/java/JavaTransformer.java b/migrator/src/com/ohos/migrator/java/JavaTransformer.java index 439c87e43..62c50357e 100644 --- a/migrator/src/com/ohos/migrator/java/JavaTransformer.java +++ b/migrator/src/com/ohos/migrator/java/JavaTransformer.java @@ -233,9 +233,11 @@ public class JavaTransformer extends ASTVisitor implements Transformer { private boolean doesOverride(ITypeBinding javaClassBinding, IMethodBinding javaCheckedMethod) { if (javaClassBinding != null) { - for (IMethodBinding javaMethod : javaClassBinding.getDeclaredMethods()) { - if (javaCheckedMethod.overrides(javaMethod)) - return true; + if (!javaClassBinding.isEqualTo(javaCheckedMethod.getDeclaringClass())) { + for (IMethodBinding javaMethod : javaClassBinding.getDeclaredMethods()) { + if (javaCheckedMethod.overrides(javaMethod)) + return true; + } } for (ITypeBinding javaInterface : javaClassBinding.getInterfaces()) { @@ -260,8 +262,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { else if ((javaModifiers & Modifier.FINAL) == 0) { // If the input (java) method is not final then output (STS) method has to be either Open or Override IMethodBinding javaMethodBinding = javaMethodDeclaration.resolveBinding(); - IMethodBinding javaDeclarationBinding = javaMethodBinding.getMethodDeclaration(); - if (doesOverride(javaDeclarationBinding.getDeclaringClass().getSuperclass(), javaDeclarationBinding)) + if (javaMethodBinding != null && doesOverride(javaMethodBinding.getDeclaringClass(), javaMethodBinding)) stsCurrent.addChild(NodeBuilder.terminalNode(StaticTSParser.Override)); else if ((javaModifiers & Modifier.STATIC) == 0 && (javaModifiers & Modifier.PRIVATE) == 0 && isInClassContext) stsCurrent.addChild(NodeBuilder.terminalNode(StaticTSParser.Open)); diff --git a/migrator/test/java/intersection-type.java.sts b/migrator/test/java/intersection-type.java.sts index 96a82304a..dea5be549 100755 --- a/migrator/test/java/intersection-type.java.sts +++ b/migrator/test/java/intersection-type.java.sts @@ -25,9 +25,9 @@ open class intersection_type { } open class auxilliary implements Runnable, Something { - public open run(): void { + public override run(): void { } - public open foo(): void { + public override foo(): void { } } diff --git a/migrator/test/java/method_invocation.java.sts b/migrator/test/java/method_invocation.java.sts index 681a206d0..b7b1808fb 100644 --- a/migrator/test/java/method_invocation.java.sts +++ b/migrator/test/java/method_invocation.java.sts @@ -25,7 +25,7 @@ open class SubClass1 extends SuperClass { override foo(): void { } tweak : Runnable = new Runnable() { - public open run(): void { + public override run(): void { SubClass1.super.foo(); } }; @@ -38,7 +38,7 @@ interface SuperInterface { } open class SubClass2 implements SuperInterface { - public open foo(): void { + public override foo(): void { } open tweak(): void { SuperInterface.super.foo(); @@ -46,10 +46,10 @@ open class SubClass2 implements SuperInterface { } open class SubClass3 implements SuperInterface { - public open foo(): void { + public override foo(): void { } tweak : Runnable = new Runnable() { - public open run(): void { + public override run(): void { } }; } -- Gitee From f53970ea8b5dbcd85fb282c2215b791509cf46b1 Mon Sep 17 00:00:00 2001 From: Mikhail Velikanov Date: Fri, 12 Aug 2022 14:24:14 +0300 Subject: [PATCH 4/5] Minor fix to two failing tests. Change-Id: Ic26ca91f309e5ae2bc1e28f7fa9dd1442d41c074 Signed-off-by: Mikhail Velikanov --- migrator/test/java/do_statement.java.sts | 12 ++++++------ migrator/test/java/while_statement.java.sts | 12 ++++++------ 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/migrator/test/java/do_statement.java.sts b/migrator/test/java/do_statement.java.sts index 081747e64..180672704 100644 --- a/migrator/test/java/do_statement.java.sts +++ b/migrator/test/java/do_statement.java.sts @@ -20,26 +20,26 @@ open class do_statement { let i : int = 0; let j : int = 0; do - break; + break; while(Flag); do { - break; + break; } while(Flag); do { i++; - if (i == 2) continue; - if (i == 5) break; + if (i == 2) continue; + if (i == 5) break; } while(i < 10); outerLoop: do { innerLoop: do { - if (j == 2) continue innerLoop; - if (i * j == 20) break outerLoop; + if (j == 2) continue innerLoop; + if (i * j == 20) break outerLoop; } while(j < 5); } diff --git a/migrator/test/java/while_statement.java.sts b/migrator/test/java/while_statement.java.sts index aa29799b7..53b82645a 100644 --- a/migrator/test/java/while_statement.java.sts +++ b/migrator/test/java/while_statement.java.sts @@ -20,23 +20,23 @@ open class while_statement { let i : int = 0; let j : int = 0; while(Flag) - break; + break; while(Flag) { - break; + break; } while(i < 10) { i++; - if (i == 2) continue; - if (i == 5) break; + if (i == 2) continue; + if (i == 5) break; } outerLoop: while(i < 5) { innerLoop: while(j < 5) { - if (j == 2) continue innerLoop; - if (i * j == 20) break outerLoop; + if (j == 2) continue innerLoop; + if (i * j == 20) break outerLoop; } } } -- Gitee From 3f99d85fa79773edbf6f6d66ba6556ae869301a7 Mon Sep 17 00:00:00 2001 From: Mikhail Velikanov Date: Fri, 12 Aug 2022 14:36:07 +0300 Subject: [PATCH 5/5] Emit dummy calls for as yet untranslated Java constructs. The original syntax of these constructs is placed inside emitted calls for reference. This is done to avoid emitting invalid STS ASTs that cause exceptions in StaticTSWriter. Change-Id: I1d2b361dbdc3e54f032fa2fb85f649a1b4b9a187 Signed-off-by: Mikhail Velikanov --- .../ohos/migrator/java/JavaTransformer.java | 179 +++++++++++------- .../ohos/migrator/staticTS/NodeBuilder.java | 30 ++- .../staticTS/writer/StaticTSWriter.java | 17 +- 3 files changed, 151 insertions(+), 75 deletions(-) diff --git a/migrator/src/com/ohos/migrator/java/JavaTransformer.java b/migrator/src/com/ohos/migrator/java/JavaTransformer.java index 62c50357e..08ab0105d 100644 --- a/migrator/src/com/ohos/migrator/java/JavaTransformer.java +++ b/migrator/src/com/ohos/migrator/java/JavaTransformer.java @@ -2686,46 +2686,6 @@ public class JavaTransformer extends ASTVisitor implements Transformer { return false; } - // Java tree: - // Annotation: - // NormalAnnotation - // MarkerAnnotation - // SingleMemberAnnotation - // SingleMemberAnnotation: - // @ TypeName ( Expression ) - // STS tree: - // TODO: - @Override - public boolean visit(NormalAnnotation javaAnnotation) { - // TODO: - return super.visit(javaAnnotation); - } - - @Override - public boolean visit(MarkerAnnotation javaAnnotation) { - // TODO: - return super.visit(javaAnnotation); - } - - @Override - public boolean visit(SingleMemberAnnotation javaAnnotation) { - // TODO: - return super.visit(javaAnnotation); - } - - // Java tree: - // CreationReference: - // Type :: - // [ < Type { , Type } > ] - // new - // STS tree: - // TODO: - @Override - public boolean visit(CreationReference javaCreationRef) { - // TODO: - return super.visit(javaCreationRef); - } - // Java tree: // FieldAccess: // Expression . Identifier @@ -2795,20 +2755,6 @@ public class JavaTransformer extends ASTVisitor implements Transformer { return false; } - // Java tree: - // LambdaExpression: - // Identifier -> Body - // ( [ Identifier { , Identifier } ] ) -> Body - // ( [ FormalParameter { , FormalParameter } ] ) -> Body - // STS tree: - // singleExpression: - // : OpenParen parameterList? CloseParen typeAnnotation Arrow lambdaBody # LambdaExpression - @Override - public boolean visit(LambdaExpression javaLambdaExpr) { - // TODO: - return false; - } - // Java tree: // MethodInvocation: // [ Expression . ] @@ -2885,17 +2831,6 @@ public class JavaTransformer extends ASTVisitor implements Transformer { return false; } - // Java tree: - // SuperMethodReference: - // [ ClassName . ] super :: [ < Type { , Type } > ] Identifier - // STS tree: - // TODO: lambda ? - @Override - public boolean visit(SuperMethodReference javaSuperMethodReference) { - // TODO: implement - return false; - } - // Java tree: // ThisExpression: // [ ClassName . ] this @@ -3236,18 +3171,116 @@ public class JavaTransformer extends ASTVisitor implements Transformer { return false; } + // AST nodes yet to be translated + // + + // Java tree: + // LambdaExpression: + // Identifier -> Body + // ( [ Identifier { , Identifier } ] ) -> Body + // ( [ FormalParameter { , FormalParameter } ] ) -> Body + // STS tree: + // singleExpression: + // : OpenParen parameterList? CloseParen typeAnnotation Arrow lambdaBody # LambdaExpression + @Override + public boolean visit(LambdaExpression javaLambdaExpr) { + // TODO: To be implemented + // Emit __untranslated_expression call with commented-out original syntax as argument for now. + // This is done to avoid building invalid STS AST which causes exceptions in StaticTSWriter. + stsCurrent.addChild(NodeBuilder.untranslatedExpression(javaLambdaExpr)).setParent(stsCurrent); + + return false; + } + + // Java tree: + // CreationReference: + // Type :: + // [ < Type { , Type } > ] + // new + // STS tree: + // TODO: + @Override + public boolean visit(CreationReference javaCreationRef) { + // TODO: To be implemented + // Emit __untranslated_expression call with commented-out original syntax as argument for now. + // This is done to avoid building invalid STS AST which causes exceptions in StaticTSWriter. + stsCurrent.addChild(NodeBuilder.untranslatedExpression(javaCreationRef)).setParent(stsCurrent); + + return false; + } + + // Java tree: + // SuperMethodReference: + // [ ClassName . ] super :: [ < Type { , Type } > ] Identifier + // STS tree: + // TODO: lambda ? + @Override + public boolean visit(SuperMethodReference javaSuperMethodReference) { + // TODO: To be implemented + // Emit __untranslated_expression call with commented-out original syntax as argument for now. + // This is done to avoid building invalid STS AST which causes exceptions in StaticTSWriter. + stsCurrent.addChild(NodeBuilder.untranslatedExpression(javaSuperMethodReference)).setParent(stsCurrent); + + return false; + } + + @Override + public boolean visit(TypeMethodReference javaTypeMethodRef) { + // TODO: To be implemented + // Emit __untranslated_expression call with commented-out original syntax as argument for now. + // This is done to avoid building invalid STS AST which causes exceptions in StaticTSWriter. + stsCurrent.addChild(NodeBuilder.untranslatedExpression(javaTypeMethodRef)).setParent(stsCurrent); + + return false; + } + + @Override + public boolean visit(ExpressionMethodReference javaExprMethodRef) { + // TODO: To be implemented + // Emit __untranslated_expression call with commented-out original syntax as argument for now. + // This is done to avoid building invalid STS AST which causes exceptions in StaticTSWriter. + stsCurrent.addChild(NodeBuilder.untranslatedExpression(javaExprMethodRef)).setParent(stsCurrent); + + return false; + } + + @Override + public boolean visit(TryStatement javaTryStatement) { + // TODO: To be implemented + // Emit __untranslated_statement call with commented-out original syntax as argument for now. + // This is done to avoid building invalid STS AST which causes exceptions in StaticTSWriter. + stsCurrent.addChild(NodeBuilder.untranslatedStatement(javaTryStatement)).setParent(stsCurrent); + + return false; + } + + @Override + public boolean visit(ThrowStatement javaThrowStatement) { + // TODO: To be implemented + // Emit __untranslated_statement call with commented-out original syntax as argument for now. + // This is done to avoid building invalid STS AST which causes exceptions in StaticTSWriter. + stsCurrent.addChild(NodeBuilder.untranslatedStatement(javaThrowStatement)).setParent(stsCurrent); + + return false; + } + + @Override + public boolean visit(SynchronizedStatement javaSynchrStmt) { + // TODO: To be implemented + // Emit __untranslated_statement call with commented-out original syntax as argument for now. + // This is done to avoid building invalid STS AST which causes exceptions in StaticTSWriter. + stsCurrent.addChild(NodeBuilder.untranslatedStatement(javaSynchrStmt)).setParent(stsCurrent); + + return false; + } + // The list of not yet translated Java Expressions: - // Expression: - // Annotation, - //?? CaseDefaultExpression, // CreationReference, //?? ExpressionMethodReference, - // InstanceofExpression, // LambdaExpression, - //? MethodReference, - //? Pattern, // SuperMethodReference, - // SwitchExpression, - // TypeLiteral, // TypeMethodReference + // TryStatement + // SynchronizedStatement + // ThrowStatement } \ No newline at end of file diff --git a/migrator/src/com/ohos/migrator/staticTS/NodeBuilder.java b/migrator/src/com/ohos/migrator/staticTS/NodeBuilder.java index fe9bf32a1..1a3ea08f0 100644 --- a/migrator/src/com/ohos/migrator/staticTS/NodeBuilder.java +++ b/migrator/src/com/ohos/migrator/staticTS/NodeBuilder.java @@ -31,7 +31,6 @@ public class NodeBuilder { public static TerminalNode terminalNode(int type) { return new TerminalNodeImpl(new CommonToken(type, stsName(type))); } - public static String stsName(int type) { // Antlr store all literal names wrapped into single quotes. Like: "'&='", "'^='", "'|='", "'=>'", "'null'", null, // "'do'", "'instanceof'", "'typeof'", "'case'", @@ -53,6 +52,9 @@ public class NodeBuilder { return new TerminalNodeImpl(new CommonToken(StaticTSParser.Identifier, identifier)); } + public static TerminalNode multiLineComment(String comment) { + return new TerminalNodeImpl(new CommonToken(StaticTSParser.MultiLineComment, comment)); + } public static TerminalNode terminalIdentifier(SimpleName name) { return terminalIdentifier(name.getIdentifier()); } @@ -393,4 +395,30 @@ public class NodeBuilder { return stsSuperCtorCall; } + + public static SingleExpressionContext untranslatedExpression(ASTNode node) { + SingleExpressionContext stsExpression = new SingleExpressionContext(null, 0); + CallExpressionContext stsCallExpression = new CallExpressionContext(stsExpression); + stsExpression.addChild(stsCallExpression).setParent(stsExpression); + + SingleExpressionContext stsIdentifier = identifierExpression("__untranslated_expression"); + stsCallExpression.addChild(stsIdentifier).setParent(stsCallExpression); + + ArgumentsContext stsArguments = new ArgumentsContext(stsCallExpression, 0); + stsCallExpression.addChild(stsArguments).setParent(stsCallExpression); + + stsArguments.addChild(multiLineComment("/*" + node.toString() + "*/")); + + return stsExpression; + } + + public static StatementContext untranslatedStatement(ASTNode node) { + StatementContext stsStatement = new StatementContext(null, 0); + ExpressionStatementContext stsExprStatement = new ExpressionStatementContext(stsStatement, 0); + stsStatement.addChild(stsExprStatement).setParent(stsStatement); + + stsExprStatement.addChild(untranslatedExpression(node)).setParent(stsExprStatement); + + return stsStatement; + } } diff --git a/migrator/src/com/ohos/migrator/staticTS/writer/StaticTSWriter.java b/migrator/src/com/ohos/migrator/staticTS/writer/StaticTSWriter.java index 7ceb559ba..f4c5e19a7 100644 --- a/migrator/src/com/ohos/migrator/staticTS/writer/StaticTSWriter.java +++ b/migrator/src/com/ohos/migrator/staticTS/writer/StaticTSWriter.java @@ -22,6 +22,7 @@ import com.ohos.migrator.staticTS.parser.StaticTSParserBaseVisitor; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.CommonTokenStream; +import org.antlr.v4.runtime.tree.ParseTree; import org.antlr.v4.runtime.tree.TerminalNode; import java.io.FileWriter; @@ -1510,13 +1511,27 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor { sb.append('('); ExpressionSequenceContext stsArgumentList = stsArguments.expressionSequence(); - if (stsArgumentList != null) visitExpressionSequence(stsArgumentList); + if (stsArgumentList != null) + visitExpressionSequence(stsArgumentList); + else if (stsArguments.getChildCount() > 0) + visitChildren(stsArguments); sb.append(')'); return null; } + @Override + public Void visitTerminal(TerminalNode stsTerminal) { + int stsTerminalCode = stsTerminal.getSymbol().getType(); + if (stsTerminalCode == StaticTSLexer.MultiLineComment || + stsTerminalCode == StaticTSLexer.SingleLineComment) { + sb.append(stsTerminal.getText()); + } + + return null; + } + // | singleExpression Instanceof singleExpression # InstanceofExpression @Override public Void visitInstanceofExpression(InstanceofExpressionContext stsInstanceofExpression) { -- Gitee