diff --git a/migrator/src/com/ohos/migrator/AbstractTranspiler.java b/migrator/src/com/ohos/migrator/AbstractTranspiler.java index f727ac86d59d310195999a38f562381aa7097bb1..196df0c8aad94c6b10e877c6b0ddb4b767c0c075 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 6cad994554787f4349c2d04cc5aa6c219eae38ff..4f8e169543d6e5570cde405c818c7d650c99d220 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 69e59aad624c7caeaed606370d18970ba8e9aaec..2d0af0e7d531f22d3b80a4a491d06b2982db92d2 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 5ecb4efc291b65cd077889f3559cff8836723848..f2cc113e4c05ccc73b7a2b6bf91267d929720c46 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 e0411fb275da06b23e366ab5e66cb3c69dc93170..8dad5a2bc25ffd6cf926f6273253ab6930dac448 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 1f6c3a5d7e4214a1b6c0d2c4352e7b4e8c12d195..08ab0105da632071e6e5815e607d2759604e5a8c 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; } @@ -221,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()) { @@ -248,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)); @@ -642,6 +655,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { popCurrent(); // ImportStatementContext + ++countDeclTransformed; return false; } @@ -686,6 +700,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { if (needPrimaryType) popCurrent(); // PrimaryTypeContext + ++countTypeTransformed; return false; } @@ -706,6 +721,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { if (needPrimaryType) popCurrent(); // PrimaryTypeContext + ++countTypeTransformed; return false; } @@ -741,6 +757,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { stsTypeRef.addChild(stsTypeRefPart).setParent(stsTypeRef); if (needPrimaryType) popCurrent(); // PrimaryTypeContext + + ++countTypeTransformed; return false; } @@ -764,6 +782,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer { if (needPrimaryType) popCurrent(); // PrimaryTypeContext + ++countTypeTransformed; return false; } @@ -804,6 +823,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { } if (needPrimaryType) popCurrent(); // PrimaryTypeContext + + ++countTypeTransformed; return false; } @@ -824,6 +845,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { } popCurrent(); // WildcardTypeContext + + ++countTypeTransformed; return false; } @@ -844,6 +867,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { popCurrent(); // ArrayTypeContext if (needPrimaryType) popCurrent(); // PrimaryTypeContext + + ++countTypeTransformed; return false; } @@ -868,6 +893,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { popCurrent(); // IntersectionTypeContext if (needPrimaryType) popCurrent(); // PrimaryTypeContext + + ++countTypeTransformed; return false; } @@ -1198,7 +1225,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()) { @@ -1208,8 +1235,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. } @@ -2446,6 +2473,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer { } popCurrent(); // ClassBodyContext + + ++countDeclTransformed; return false; } @@ -2657,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 @@ -2766,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 . ] @@ -2856,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 @@ -3207,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 fe9bf32a166d28c03dff27c856dfad7c4a9a2a77..1a3ea08f0e162113268fdad24de0a56301235709 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 7ceb559baf995d7e038b0a93ec6fadc32fa2331a..f4c5e19a7e441db8ca4569bbd02861980bc0e9f4 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) { diff --git a/migrator/test/java/do_statement.java.sts b/migrator/test/java/do_statement.java.sts index 081747e643564a8d2364d9e587049bd479827f98..180672704284a3a897572cc1f1eea097baa29f2c 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/intersection-type.java.sts b/migrator/test/java/intersection-type.java.sts index 96a82304a83561c6e3ebdfba83aed1e1f43db65a..dea5be549e5fe128740a895420502f8b19feb374 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 681a206d0c6673ed9086b4eacc048bd88b8c63d6..b7b1808fb2cef72361fb6a925390702eb0c3fea5 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 { } }; } diff --git a/migrator/test/java/while_statement.java.sts b/migrator/test/java/while_statement.java.sts index aa29799b7830116f7a165fdeb97eeff55e5bc3a7..53b82645a526afd206af5ea20d64754821180fc4 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; } } }