diff --git a/migrator/src/com/ohos/migrator/Main.java b/migrator/src/com/ohos/migrator/Main.java
index 9663c2e9d57a292857e7841fd76f229ef23439dd..d5aaeafeb71940e6cec28b17a94bacf3c6ca03a5 100644
--- a/migrator/src/com/ohos/migrator/Main.java
+++ b/migrator/src/com/ohos/migrator/Main.java
@@ -256,10 +256,15 @@ public class Main {
         ResultCode code = stsChecker.transpile();
         errorList.addAll(stsChecker.getErrorList());
 
-        if (code == ResultCode.OK) 
+        if (code == ResultCode.OK) {
             System.out.println("Syntax OK.");
-	else 
-            System.out.println("Bad syntax!");
+        }
+	    else {
+            System.out.println("Bad syntax in the following files:");
+            for (File failedFile : stsChecker.getOutFiles())
+                System.out.println(failedFile.getPath());
+        }
+
         return code;
     }
 }
diff --git a/migrator/src/com/ohos/migrator/java/JavaParser.java b/migrator/src/com/ohos/migrator/java/JavaParser.java
index 203a79f27cc30b2397b424823ebfaceb9d4ed641..c3b684aae51abd6ccc7d3a3d9b407a65ad4f018a 100644
--- a/migrator/src/com/ohos/migrator/java/JavaParser.java
+++ b/migrator/src/com/ohos/migrator/java/JavaParser.java
@@ -80,6 +80,8 @@ public class JavaParser {
         this.source = source;
     }
 
+    public char[] getJavaSource() { return source; }
+
     private static String getPackagePath(File file) {
         // If already processed this file, return the result from cache.
         if (packagePaths.containsKey(file)) {
diff --git a/migrator/src/com/ohos/migrator/java/JavaTransformer.java b/migrator/src/com/ohos/migrator/java/JavaTransformer.java
index 5068db07eb629032bcf6ddea3153eea3b6c27972..a435e7e87aa4c5360f120394ffe0e32b4a0e7c93 100644
--- a/migrator/src/com/ohos/migrator/java/JavaTransformer.java
+++ b/migrator/src/com/ohos/migrator/java/JavaTransformer.java
@@ -18,6 +18,7 @@ package com.ohos.migrator.java;
 import com.ohos.migrator.Main;
 import com.ohos.migrator.ResultCode;
 import com.ohos.migrator.Transformer;
+import com.ohos.migrator.staticTS.parser.StaticTSContextBase;
 import com.ohos.migrator.staticTS.parser.StaticTSParser;
 import com.ohos.migrator.staticTS.parser.StaticTSParser.*;
 
@@ -34,11 +35,13 @@ import java.util.*;
  */
 public class JavaTransformer extends ASTVisitor implements Transformer {
     private final CompilationUnit javaCU;
-    private CompilationUnitContext stsCU;
 
+    private final char[] javaSource;
+    private CompilationUnitContext stsCU;
     private final File srcFile;
     private ParserRuleContext stsCurrent;
 
+    private LinkedList<Comment> javaComments = new LinkedList<>();
     private final Stack<ParserRuleContext> stsSaved = new Stack<>();
     private final Stack<TrapStatementContext> stsCurrentTrapStatement = new Stack<>();
 
@@ -46,22 +49,19 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
     // so the list of collected exceptions for the 'outer' method might get mixed
     // with exceptions of the method of 'nested' class so use stack
     private final Stack<Set<ITypeBinding>> javaThrownExceptions = new Stack<>();
-
     private final String INIT_THROWN_EXEPTIONS = "INIT_THROWN_EXCEPTIONS";
-
     private final String INSTANCE_INITIALIZER = "INSTANCE_INITIALIZER";
     private final String USED_IN_ANOTHER_CASE_CLAUSE = "USED_IN_ANOTHER_CASE_CLAUSE";
     private final String ENUM_TYPE_NAME = "ENUM_TYPE_NAME";
     private final String ENUM_CONST_ORDINAL = "ENUM_CONST_ORDINAL";
-
     private final String OUTER_OBJECT = "OUTER_OBJECT";
-
     private final String CTOR_ARGUMENTS = "CTOR_ARGUMENTS";
+
+    private final String LEADING_COMMENTS = "LEADING_COMMENTS";
+    private final String TRAILING_COMMENT = "TRAILING_COMMENT";
     private final String RUNTIME_EXCEPTION_TYPE_NAME = "java.lang.RuntimeException";
     private final String THROWABLE_TYPE_NAME = "java.lang.Throwable";
-
     private final String METHOD_REF_PARAM_PREFIX = "__migrator_lambda_param_";
-
     private final ITypeBinding RUNTIME_EXCEPTION_TYPE;
     private final ITypeBinding THROWABLE_TYPE;
 
@@ -226,9 +226,10 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
         popStatement(); // IterationStatement, StatementContext
     }
 
-    public JavaTransformer(CompilationUnit javaCU, File srcFile) {
+    public JavaTransformer(CompilationUnit javaCU, char[] javaSource, File srcFile) {
         this.javaCU = javaCU;
         this.srcFile = srcFile;
+        this.javaSource = javaSource;
         AST javaAST = this.javaCU.getAST();
         RUNTIME_EXCEPTION_TYPE = javaAST.resolveWellKnownType(RUNTIME_EXCEPTION_TYPE_NAME);
         THROWABLE_TYPE = javaAST.resolveWellKnownType(THROWABLE_TYPE_NAME);
@@ -433,7 +434,7 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
                 @Override
                 public boolean visit(SynchronizedStatement node) {
                     node.getExpression().accept(this);
-                    
+
                     // We don't visit the block itself, only statements inside it.
                     visitBodyStatements(node.getBody());
 
@@ -457,7 +458,117 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
     }
 
     @Override
-    public boolean visit(CompilationUnit javaCu) {
+    public void preVisit(ASTNode javaNode) {
+        // Skip compilation unit - it starts at 0, anyway,
+        // so no comments can be ahead of it.
+        if (javaNode.getNodeType() == ASTNode.COMPILATION_UNIT)
+            return;
+
+        // Pick up all comments that we haven't processed yet
+        // which are in front of the current AST node.
+        int javaNodeStart = javaNode.getStartPosition();
+        List<TerminalNode> stsLeadingComments = new LinkedList<>();
+        while (!javaComments.isEmpty()) {
+            Comment javaComment = javaComments.get(0);
+            int javaCommentStart = javaComment.getStartPosition();
+
+            if (javaCommentStart < javaNodeStart) {
+                stsLeadingComments.add(createCommentNode(javaComment));
+                javaComments.removeFirst();
+            }
+            else break;
+        }
+
+        // Hoist list of leading comments onto Java AST node for the moment.
+        // We'll transfer it to STS AST node when we've created it.
+        if (!stsLeadingComments.isEmpty())
+            javaNode.setProperty(LEADING_COMMENTS, stsLeadingComments);
+
+        // Skip comments inside current AST node.
+        int i = 0;
+        int javaNodeEnd = javaNodeStart + javaNode.getLength();
+        while (i < javaComments.size()) {
+            int javaCommentStart = javaComments.get(i).getStartPosition();
+            if (javaCommentStart < javaNodeEnd)
+                ++i;
+            else break;
+        }
+
+        // Pick up the comment immediately after the current AST node if
+        // intervening characters are all whitespace except line terminator.
+        // If such comment exists, hoist it onto the Java AST node as well.
+        if (i < javaComments.size()) {
+            Comment javaComment = javaComments.get(i);
+            int javaCommentStart = javaComment.getStartPosition();
+
+            String space = new String(javaSource, javaNodeEnd, javaCommentStart - javaNodeEnd);
+            if (space.isBlank() && !space.contains("\n")) {
+                javaNode.setProperty(TRAILING_COMMENT, createCommentNode(javaComment));
+                javaComments.remove(javaComment);
+            }
+        }
+    }
+    private TerminalNode createCommentNode(Comment javaComment) {
+        int javaCommentLen = javaComment.getLength();
+        int javaCommentStart = javaComment.getStartPosition();
+        String javaCommentText = new String(javaSource, javaCommentStart, javaCommentLen);
+
+        if (javaComment.isLineComment())
+            return NodeBuilder.singleLineComment(javaCommentText);
+
+        // Use multiline comment for JavaDoc comments, too
+        return NodeBuilder.multiLineComment(javaCommentText);
+    }
+
+    private void transferComments(ASTNode javaNode, StaticTSContextBase stsNode) {
+        // Transfer comments from Java AST node (if any) to
+        // STS AST node, removing them from the former.
+        Object propObject = javaNode.getProperty(LEADING_COMMENTS);
+        if (propObject != null) {
+            stsNode.setLeadingComments((List<TerminalNode>)propObject);
+            javaNode.setProperty(LEADING_COMMENTS, null);
+        }
+        propObject = javaNode.getProperty(TRAILING_COMMENT);
+        if (propObject != null) {
+            stsNode.addTrailingComment((TerminalNode)propObject);
+            javaNode.setProperty(TRAILING_COMMENT, null);
+        }
+    }
+    @Override
+    public void postVisit(ASTNode javaNode) {
+        // Sanity check.
+        ParseTree lastChild = stsCurrent.getChild(stsCurrent.getChildCount()-1);
+        if (lastChild == null || !(lastChild instanceof StaticTSContextBase)) return;
+
+        // Transfer leading (if any) from Java AST node to the STS AST node we just added
+        StaticTSContextBase stsLastChild = (StaticTSContextBase)lastChild;
+        Object propObj = javaNode.getProperty(LEADING_COMMENTS);
+        if (propObj != null)
+            stsLastChild.setLeadingComments((List<TerminalNode>)propObj);
+
+        // Pick up all comments inside the current AST node that haven't been
+        // picked up by its child nodes. Hopefully, this won't happen too often.
+        int javaNodeEnd = javaNode.getStartPosition() + javaNode.getLength();
+        while (!javaComments.isEmpty()) {
+            Comment javaComment = javaComments.get(0);
+            int javaCommentStart = javaComment.getStartPosition();
+
+            if (javaCommentStart < javaNodeEnd) {
+                stsLastChild.addTrailingComment(createCommentNode(javaComment));
+                javaComments.removeFirst();
+            }
+            else break;
+        }
+
+        // Transfer trailing comment (if any).
+        propObj = javaNode.getProperty(TRAILING_COMMENT);
+        if (propObj != null)
+            stsLastChild.addTrailingComment((TerminalNode)propObj);
+    }
+
+    @Override
+    public boolean visit(CompilationUnit javaCU) {
+        javaComments.addAll(javaCU.getCommentList());
         pushCurrent(stsCU = new CompilationUnitContext(null, 0));
         return true;
     }
@@ -481,12 +592,10 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
     //       TerminalNode <;>
     @Override
     public boolean visit(PackageDeclaration javaPackageDeclaration) {
-        assert(stsCurrent == stsCU);
         pushCurrent(new PackageDeclarationContext(stsCU, 0));
 
         stsCurrent.addChild(NodeBuilder.terminalNode(StaticTSParser.Package));
         stsCurrent.addChild(NodeBuilder.qualifiedName(javaPackageDeclaration.getName())).setParent(stsCurrent);
-        stsCurrent.addChild(NodeBuilder.terminalNode(StaticTSParser.SemiColon));
 
         popCurrent(); // PackageDeclarationContext
 
@@ -1692,14 +1801,14 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
         if (javaMethodDeclaration.isConstructor() && javaBlock == null) {
             // Warn and emit a comment with original source code of the constructor.
             reportError("Invalid constructor declaration without a body", javaMethodDeclaration);
-            stsCurrent.addChild(NodeBuilder.multiLineComment("/* Untranslated constructor declaration:\n" +
-                                                            javaMethodDeclaration.toString() + "\n*/\n"));
+            stsCurrent.addChild(NodeBuilder.dummyNode("Untranslated constructor declaration:\n" +
+                                                            javaMethodDeclaration.toString()));
             return false;
         }
         else if (!javaMethodDeclaration.isConstructor() && javaMethodDeclaration.getReturnType2() == null) {
             reportError("Invalid method declaration without return type", javaMethodDeclaration);
-            stsCurrent.addChild(NodeBuilder.multiLineComment("/* Untranslated method declaration:\n" +
-                                                            javaMethodDeclaration.toString() + "\n*/\n"));
+            stsCurrent.addChild(NodeBuilder.dummyNode("Untranslated method declaration:\n" +
+                                                            javaMethodDeclaration.toString()));
             return false;
         }
         // create thrown exception set for current method
@@ -2590,8 +2699,8 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
         if (stsCurrent.getRuleIndex() != StaticTSParser.RULE_classBody) {
             // Warn and emit a comment with original source code of initializer
             reportError("Invalid context for initializer", javaInitializer);
-            stsCurrent.addChild(NodeBuilder.multiLineComment("/* Untranslated initializer:\n" +
-                    javaInitializer.toString() + "\n*/\n"));
+            stsCurrent.addChild(NodeBuilder.dummyNode("Untranslated initializer:\n" +
+                                                        javaInitializer.toString()));
             return false;
         }
 
@@ -3576,6 +3685,10 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
                 wrapCaseClauseStatementsWithBlock();
             }
             else if (javaStmt.getNodeType() == ASTNode.VARIABLE_DECLARATION_STATEMENT) {
+                // Call preVisit to collect comments that may be attached to this
+                // statement. NOTE: We won't be visiting it so preVisit won't be
+                // called automatically.
+                preVisit(javaStmt);
                 processSwitchCaseVariableDeclaration((VariableDeclarationStatement) javaStmt, javaCurrentSwitchCase,
                         javaSwitchStmt, javaVariablesToMove);
 
@@ -3615,13 +3728,18 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
             for (VariableDeclarationFragment javaVarFragment : javaVariablesToMove) {
                 VariableDeclarationStatement javaVarDeclStmt = (VariableDeclarationStatement) javaVarFragment.getParent();
 
-                pushStatement(new VariableOrConstantDeclarationContext(null, 0));
+                VariableOrConstantDeclarationContext stsVarOrConstDecl = new VariableOrConstantDeclarationContext(null, 0);
+                pushStatement(stsVarOrConstDecl);
+
+                // Transfer comments from javaVarDeclStmt node (if any) to
+                // STS VariableOrConstantDeclarationContext node.
+                transferComments(javaVarDeclStmt, stsVarOrConstDecl);
 
                 ArrayList<VariableDeclarationFragment> declFragmentList = new ArrayList<>();
                 declFragmentList.add(javaVarFragment);
 
                 createAndFillVarOrConstDeclarationList(javaVarDeclStmt.getModifiers(), declFragmentList, javaVarDeclStmt.getType(), false);
-                popStatement(); // VariableOrConstantDeclarationContext
+                popStatement(); // stsVarOrConstDecl
             }
 
             pushStatement(stsSwitch);
@@ -3728,7 +3846,6 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
         // case clause and, in such case, move declaration of that variable in front of
         // switch statement, additionally enclosing both variable declaration and switch
         // statement, so that variables are only visible in context of switch statement.
-
         List<VariableDeclarationFragment> javaVarFragments = javaVarDeclStmt.fragments();
 
         for (VariableDeclarationFragment javaVarFragment : javaVarFragments) {
@@ -3759,13 +3876,18 @@ public class JavaTransformer extends ASTVisitor implements Transformer {
                 // declaration here to preserve the correct order of evaluation of
                 // initializer expressions (including assignments emitted for variables
                 // that are moved).
-                pushStatement(new VariableOrConstantDeclarationContext(null, 0));
+                VariableOrConstantDeclarationContext stsVarOrConstDecl = new VariableOrConstantDeclarationContext(null, 0);
+                pushStatement(stsVarOrConstDecl);
+
+                // Transfer comments from javaVarDeclStmt node (if any) to
+                // STS VariableOrConstantDeclarationContext node.
+                transferComments(javaVarDeclStmt, stsVarOrConstDecl);
 
                 ArrayList<VariableDeclarationFragment> declFragmentList = new ArrayList<>();
                 declFragmentList.add(javaVarFragment);
 
                 createAndFillVarOrConstDeclarationList(javaVarDeclStmt.getModifiers(), declFragmentList, javaVarDeclStmt.getType());
-                popStatement(); // VariableOrConstantDeclarationContext
+                popStatement(); // stsVarOrConstDecl
             }
         }
 
diff --git a/migrator/src/com/ohos/migrator/java/JavaTranspiler.java b/migrator/src/com/ohos/migrator/java/JavaTranspiler.java
index 3899959e7a0a9cc08272f0e0a112b16b605ee880..f7c2a91fe8fe842fdc292bace9935d57f92cb8b6 100644
--- a/migrator/src/com/ohos/migrator/java/JavaTranspiler.java
+++ b/migrator/src/com/ohos/migrator/java/JavaTranspiler.java
@@ -39,6 +39,7 @@ import java.util.List;
 public class JavaTranspiler extends AbstractTranspiler {
 
     private boolean noxrefs = false;
+    private JavaParser javaParser;
     public JavaTranspiler(List<File> src, List<File> libs, String outDir, boolean noxrefs) {
        super(src, libs, outDir);
        this.noxrefs = noxrefs;
@@ -68,12 +69,13 @@ public class JavaTranspiler extends AbstractTranspiler {
     }
 
     private CompilationUnit parse(File srcFile) throws IOException, JavaParserException {
-        JavaParser parser = new JavaParser(srcFile, sourceFiles, libFiles, noxrefs);
-        return parser.parse();
+        javaParser = new JavaParser(srcFile, sourceFiles, libFiles, noxrefs);
+        return javaParser.parse();
     }
 
     private CompilationUnitContext transform(CompilationUnit javaCU, File srcFile) {
-        JavaTransformer transformer = new JavaTransformer(javaCU, srcFile);
+        char[] javaSource = javaParser.getJavaSource();
+        JavaTransformer transformer = new JavaTransformer(javaCU, javaSource, srcFile);
         return transformer.transform();
     }
 
diff --git a/migrator/src/com/ohos/migrator/java/NodeBuilder.java b/migrator/src/com/ohos/migrator/java/NodeBuilder.java
index f402439ecb709472e6589c89f4ce566856f80988..94e71e0c110098b57d71b598c380d528bd8bfddd 100644
--- a/migrator/src/com/ohos/migrator/java/NodeBuilder.java
+++ b/migrator/src/com/ohos/migrator/java/NodeBuilder.java
@@ -173,7 +173,7 @@ public class NodeBuilder extends NodeBuilderBase {
         TypeAnnotationContext stsTypeAnnotation = unknownTypeAnnotation();
 
         if (javaType != null) {
-            stsTypeAnnotation.addChild(multiLineComment("/* " + javaType.toString() + " */"));
+            stsTypeAnnotation.addTrailingComment(multiLineComment("/* " + javaType.toString() + " */"));
         }
 
         return stsTypeAnnotation;
@@ -183,7 +183,7 @@ public class NodeBuilder extends NodeBuilderBase {
         TypeAnnotationContext stsTypeAnnotation = unknownTypeAnnotation();
 
         if (javaTypeBinding != null) {
-            stsTypeAnnotation.addChild(multiLineComment("/* " + javaTypeBinding.getName() + " */"));
+            stsTypeAnnotation.addTrailingComment(multiLineComment("/* " + javaTypeBinding.getName() + " */"));
         }
 
         return stsTypeAnnotation;
diff --git a/migrator/src/com/ohos/migrator/staticTS/NodeBuilderBase.java b/migrator/src/com/ohos/migrator/staticTS/NodeBuilderBase.java
index bb5336a1e12ff4789c96cc26d5715b206a208de3..24b6afae7f99cdafb52b8654ea1bbbaa1e02a24b 100644
--- a/migrator/src/com/ohos/migrator/staticTS/NodeBuilderBase.java
+++ b/migrator/src/com/ohos/migrator/staticTS/NodeBuilderBase.java
@@ -15,6 +15,8 @@
 
 package com.ohos.migrator.staticTS;
 
+import com.ohos.migrator.staticTS.parser.DummyContext;
+import com.ohos.migrator.staticTS.parser.StaticTSContextBase;
 import com.ohos.migrator.staticTS.parser.StaticTSParser;
 import com.ohos.migrator.staticTS.parser.StaticTSParser.*;
 import org.antlr.v4.runtime.CommonToken;
@@ -59,6 +61,10 @@ public class NodeBuilderBase {
         return new TerminalNodeImpl(new CommonToken(StaticTSParser.MultiLineComment, comment));
     }
 
+    public static TerminalNode singleLineComment(String comment) {
+        return new TerminalNodeImpl(new CommonToken(StaticTSParser.SingleLineComment, comment));
+    }
+
     // The 'name' here is expected to be a dot-separated sequence of names: 'name' '.' 'name' '.' 'name' ...
     public static QualifiedNameContext qualifiedName(String fqname) {
         QualifiedNameContext stsQualifiedName = new QualifiedNameContext(null, 0);
@@ -222,9 +228,12 @@ public class NodeBuilderBase {
     }
 
     public static TypeReferenceContext unknownTypeReference(String comment) {
-        String typeName = UNKNOWN_TYPE_NAME;
-        if (comment != null) typeName += " /* " + comment + " */";
-        return typeReference(typeName);
+        TypeReferenceContext stsTypeRef = typeReference(UNKNOWN_TYPE_NAME);
+        if (comment != null) {
+            TerminalNode stsComment = multiLineComment("/* " + comment + " */");
+            stsTypeRef.addTrailingComment(stsComment);
+        }
+        return stsTypeRef;
     }
 
     // STS tree:
@@ -336,11 +345,21 @@ public class NodeBuilderBase {
         ArgumentsContext stsArguments = new ArgumentsContext(stsCallExpression, 0);
         stsCallExpression.addChild(stsArguments).setParent(stsCallExpression);
 
-        stsArguments.addChild(multiLineComment("/* " + comment + " */"));
+        // Create empty argument list and add trailing comment to it to make sure the comment
+        // appears inside parentheses (see StaticTSWriter.visitArguments for details)
+        ExpressionSequenceContext stsArgList = new ExpressionSequenceContext(stsArguments, 0);
+        stsArguments.addChild(stsArgList).setParent(stsArguments);
+
+        stsArgList.addTrailingComment(multiLineComment("/* " + comment + " */"));
 
         return stsExpression;
     }
 
+    public static DummyContext dummyNode(String comment) {
+        DummyContext stsDummyContext = new DummyContext(null, 0);
+        stsDummyContext.addLeadingComment(multiLineComment("/* " + comment + " */"));
+        return stsDummyContext;
+    }
     public static boolean needStatementOrLocalDeclaration(ParserRuleContext stsContext) {
         return stsContext.getRuleIndex() == StaticTSParser.RULE_block
                 || stsContext.getRuleIndex() == StaticTSParser.RULE_constructorBody;
diff --git a/migrator/src/com/ohos/migrator/staticTS/StaticTSSyntaxChecker.java b/migrator/src/com/ohos/migrator/staticTS/StaticTSSyntaxChecker.java
index 997069ef65653247ec3b892ca8319c192cbe1a07..80276ebf86e168528a4a614909c481c0519f2498 100644
--- a/migrator/src/com/ohos/migrator/staticTS/StaticTSSyntaxChecker.java
+++ b/migrator/src/com/ohos/migrator/staticTS/StaticTSSyntaxChecker.java
@@ -24,6 +24,7 @@ import org.antlr.v4.runtime.misc.ParseCancellationException;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.LinkedList;
 import java.util.List;
 
 public class StaticTSSyntaxChecker extends AbstractTranspiler {
@@ -34,6 +35,7 @@ public class StaticTSSyntaxChecker extends AbstractTranspiler {
 
     @Override
     public void transpileFile(File srcFile) throws TranspileException {
+        boolean syntaxOK = false;
         try {
             CharStream input = CharStreams.fromFileName(srcFile.getAbsolutePath());
             StaticTSLexer lexer = new StaticTSLexer(input);
@@ -42,12 +44,13 @@ public class StaticTSSyntaxChecker extends AbstractTranspiler {
             parser.setErrorHandler(new CheckerErrorStrategy());
             parser.removeParseListeners();
 
-            StaticTSParser.CompilationUnitContext stsCU = parser.compilationUnit();
+            parser.compilationUnit();
             List<String> msgList = SyntaxErrorListener.INSTANCE.getMsgList();
             if( !msgList.isEmpty()) {
                 throw new TranspileException(ResultCode.ParseError, new SyntaxCheckException(msgList));
             }
 
+            syntaxOK = true;
         } catch (IOException e) {
             throw new TranspileException(ResultCode.InputError, e);
         } catch (RecognitionException e) {
@@ -55,8 +58,13 @@ public class StaticTSSyntaxChecker extends AbstractTranspiler {
         } catch (ParseCancellationException e) {
             throw new TranspileException(ResultCode.ParseError, "File " + srcFile.getPath() + " failed syntax check!");
         }  finally {
+            if (!syntaxOK) outFiles.add(srcFile);
             SyntaxErrorListener.INSTANCE.clearMsgList();
-	}
+	    }
+    }
 
+    @Override
+    protected void writeUntranslatedFile(File srcFile) {
+        // Do nothing, as we're not translating here.
     }
 }
diff --git a/migrator/src/com/ohos/migrator/staticTS/parser/DummyContext.java b/migrator/src/com/ohos/migrator/staticTS/parser/DummyContext.java
new file mode 100755
index 0000000000000000000000000000000000000000..01c35e47b1d8d68037ab474fdd7fb94612bd0770
--- /dev/null
+++ b/migrator/src/com/ohos/migrator/staticTS/parser/DummyContext.java
@@ -0,0 +1,22 @@
+package com.ohos.migrator.staticTS.parser;
+
+import com.ohos.migrator.staticTS.writer.StaticTSWriter;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ParseTreeVisitor;
+
+public class DummyContext extends StaticTSContextBase {
+    public DummyContext() { }
+
+    public DummyContext(ParserRuleContext parent, int invokingStateNumber) {
+        super(parent, invokingStateNumber);
+    }
+
+    @Override
+    public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
+        if (visitor instanceof StaticTSWriter) {
+            ((StaticTSWriter) visitor).visitDummyNode(this);
+            return null;
+        }
+        return visitor.visitChildren(this);
+    }
+}
diff --git a/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSContextBase.java b/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSContextBase.java
new file mode 100755
index 0000000000000000000000000000000000000000..87309989bb7ea3e40b0b50e07240762ee8fb2851
--- /dev/null
+++ b/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSContextBase.java
@@ -0,0 +1,54 @@
+package com.ohos.migrator.staticTS.parser;
+
+import com.ohos.migrator.staticTS.writer.StaticTSWriter;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ParseTreeVisitor;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class StaticTSContextBase extends ParserRuleContext {
+    private List<TerminalNode> leadingComments;
+    private List<TerminalNode> trailingComments;
+
+    public StaticTSContextBase() { }
+
+    public StaticTSContextBase(ParserRuleContext parent, int invokingStateNumber) {
+        super(parent, invokingStateNumber);
+    }
+
+    public void addLeadingComment(TerminalNode stsComment) {
+        if (leadingComments == null) leadingComments = new LinkedList<>();
+        leadingComments.add(stsComment);
+    }
+
+    public void addTrailingComment(TerminalNode stsComment) {
+        if (trailingComments == null) trailingComments = new LinkedList<>();
+        trailingComments.add(stsComment);
+    }
+
+    public void setLeadingComments(List<TerminalNode> stsComments) {
+        leadingComments = stsComments;
+    }
+
+    public void setTrailingComments(List<TerminalNode> stsComments) {
+        trailingComments = stsComments;
+    }
+
+    public List<TerminalNode> getLeadingComments() {
+        return leadingComments;
+    }
+
+    public List<TerminalNode> getTrailingComments() {
+        return trailingComments;
+    }
+
+    public boolean hasLeadingComments() {
+        return leadingComments != null && !leadingComments.isEmpty();
+    }
+
+    public boolean hasTrailingComments() {
+        return trailingComments != null && !trailingComments.isEmpty();
+    }
+}
diff --git a/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSParser.g4 b/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSParser.g4
index c6caa68336e455e8144bb6ad1ff90638df719e03..b9cfeb56375be1ca8299af871a25de9fbe590da1 100644
--- a/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSParser.g4
+++ b/migrator/src/com/ohos/migrator/staticTS/parser/StaticTSParser.g4
@@ -47,6 +47,7 @@ parser grammar StaticTSParser;
 options {
     tokenVocab=StaticTSLexer;
     superClass=StaticTSParserBase;
+    contextSuperClass=StaticTSContextBase;
 }
 
 @members {
diff --git a/migrator/src/com/ohos/migrator/staticTS/writer/StaticTSWriter.java b/migrator/src/com/ohos/migrator/staticTS/writer/StaticTSWriter.java
index a522fa378c5b6a85ccc7e9ab22dedf1c2aaea065..424289de134d6638e28cd4efc15564a755709678 100644
--- a/migrator/src/com/ohos/migrator/staticTS/writer/StaticTSWriter.java
+++ b/migrator/src/com/ohos/migrator/staticTS/writer/StaticTSWriter.java
@@ -17,6 +17,7 @@ package com.ohos.migrator.staticTS.writer;
 
 import com.ohos.migrator.Main;
 import com.ohos.migrator.ResultCode;
+import com.ohos.migrator.staticTS.parser.StaticTSContextBase;
 import com.ohos.migrator.staticTS.parser.StaticTSLexer;
 import com.ohos.migrator.staticTS.parser.StaticTSParser;
 import com.ohos.migrator.staticTS.parser.StaticTSParser.*;
@@ -26,8 +27,10 @@ import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonTokenStream;
 import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.RuleNode;
 import org.antlr.v4.runtime.tree.TerminalNode;
 
+import javax.xml.stream.events.Comment;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.Writer;
@@ -100,22 +103,66 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         return false;
     }
+    private void writeLeadingComments(StaticTSContextBase stsNode) {
+        if (stsNode == null || !stsNode.hasLeadingComments()) return;
+
+        for (TerminalNode stsComment : stsNode.getLeadingComments()) {
+            stsComment.accept(this);
+            sb.append('\n');
+        }
+    }
+
+    private void writeTrailingComments(StaticTSContextBase stsNode) {
+        if (stsNode == null || !stsNode.hasTrailingComments()) return;
+
+        List<TerminalNode> stsComments = stsNode.getTrailingComments();
+        int numLF = 0;
+        while (sb.charAt(sb.length()-numLF-1) == '\n')
+            ++numLF;
+
+        TerminalNode stsFirstComment = stsComments.get(0);
+        if (stsComments.size() == 1 && stsFirstComment.getText().indexOf('\n') == -1) {
+            // Special treatment for the single one-line trailing comment:
+            // Make sure there is always a space in front of the comment.
+            // If there are line terminators there, emit them after the comment.
+            if (numLF > 0)
+                sb.setLength(sb.length()-numLF);
+
+            sb.append(' ');
+
+            stsFirstComment.accept(this);
+            if (numLF > 0) sb.append("\n".repeat(numLF));
+        }
+        else {
+            // Otherwise, emit line terminator after each comment, adding
+            // one in front of the first comment if it's not there already.
+            if (numLF == 0) sb.append('\n');
+            for (TerminalNode stsComment : stsComments) {
+                stsComment.accept(this);
+                sb.append('\n');
+            }
+        }
+    }
 
     // initializer: '=' (arrayLiteral | singleExpression)
     @Override
     public Void visitInitializer(InitializerContext stsInitializer) {
+        writeLeadingComments(stsInitializer);
+
         sb.append("= ");
 
         SingleExpressionContext stsExpression = stsInitializer.singleExpression();
         assert(stsExpression != null);
         stsExpression.accept(this);
 
+        writeTrailingComments(stsInitializer);
         return null;
     }
 
     // typeParameters: '<' typeParameterList? '>'
     @Override
     public Void visitTypeParameters(TypeParametersContext stsTypeParameters) {
+        writeLeadingComments(stsTypeParameters);
         sb.append('<');
 
         TypeParameterListContext stsTypeParameterList = stsTypeParameters.typeParameterList();
@@ -125,12 +172,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append('>');
 
+        writeTrailingComments(stsTypeParameters);
         return null;
     }
 
     // typeParameterList: typeParameter (',' typeParameter)*;
     @Override
     public Void visitTypeParameterList(TypeParameterListContext stsTypeParameterList) {
+        writeLeadingComments(stsTypeParameterList);
+
         int i = 0;
         for (TypeParameterContext stsTypeParameter : stsTypeParameterList.typeParameter()) {
             if (i > 0) sb.append(", ");
@@ -138,12 +188,14 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             ++i;
         }
 
+        writeTrailingComments(stsTypeParameterList);
         return null;
     }
 
     // typeParameter: ({ this.next(IN) || this.next(OUT) }? Identifier)? Identifier constraint?
     @Override
     public Void visitTypeParameter(TypeParameterContext stsTypeParameter) {
+        writeLeadingComments(stsTypeParameter);
         List<TerminalNode> stsIdentifiers = stsTypeParameter.Identifier();
 
         if (stsIdentifiers.size() > 1) {
@@ -167,22 +219,21 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitConstraint(stsConstraint);
         }
 
+        writeTrailingComments(stsTypeParameter);
         return null;
     }
 
     // constraint: 'extends' type_
     @Override
     public Void visitConstraint(ConstraintContext stsConstraint) {
+        writeLeadingComments(stsConstraint);
+
         TerminalNode termExtends = stsConstraint.Extends();
         sb.append(termExtends.getText()).append(' ');
 
         TypeReferenceContext stsType = stsConstraint.typeReference();
         if (stsType != null) {
             visitTypeReference(stsType);
-
-            // We may have added a comment here if type reference was invalid.
-            // See JavaTransformer.visit(TypeParameter) for details.
-            visitComment(stsConstraint, 2);
         }
         else {
             IntersectionTypeContext stsIntersectionType = stsConstraint.intersectionType();
@@ -190,12 +241,14 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitIntersectionType(stsIntersectionType);
         }
 
+        writeTrailingComments(stsConstraint);
         return null;
     }
 
     // typeArguments: '<' typeArgumentList? '>'
     @Override
     public Void visitTypeArguments(TypeArgumentsContext stsTypeArguments) {
+        writeLeadingComments(stsTypeArguments);
         sb.append('<');
 
         TypeArgumentListContext stsTypeArgumentList = stsTypeArguments.typeArgumentList();
@@ -205,12 +258,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append('>');
 
+        writeTrailingComments(stsTypeArguments);
         return null;
     }
 
     // typeArgumentList: typeArgument (',' typeArgument)*
     @Override
     public Void visitTypeArgumentList(TypeArgumentListContext stsTypeArgumentList) {
+        writeLeadingComments(stsTypeArgumentList);
+
         int i = 0;
         for (TypeArgumentContext stsTypeArgument : stsTypeArgumentList.typeArgument()) {
             if (i > 0) sb.append(", ");
@@ -218,12 +274,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             ++i;
         }
 
+        writeTrailingComments(stsTypeArgumentList);
         return null;
     }
 
     // typeArgument: typeReference | arrayType | wildcardType
     @Override
     public Void visitTypeArgument(TypeArgumentContext stsTypeArgument) {
+        writeLeadingComments(stsTypeArgument);
+
         TypeReferenceContext stsTypeReference = stsTypeArgument.typeReference();
         if (stsTypeReference != null) {
             visitTypeReference(stsTypeReference);
@@ -240,12 +299,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             }
         }
 
+        writeTrailingComments(stsTypeArgument);
         return null;
     }
 
     // wildcardType: { this.next(IN) }? Identifier typeReference | { this.next(OUT) }? Identifier typeReference?
     @Override
     public Void visitWildcardType(WildcardTypeContext stsWildcardType) {
+        writeLeadingComments(stsWildcardType);
+
         // Sanity check: Leading identifier should be either 'in' or 'out'
         String stsIdentifier = stsWildcardType.Identifier().getText();
         if (!StaticTSParser.IN.equals(stsIdentifier) && !StaticTSParser.OUT.equals(stsIdentifier)) {
@@ -261,6 +323,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitTypeReference(stsTypeRef);
         }
 
+        writeTrailingComments(stsWildcardType);
         return null;
     }
 
@@ -271,41 +334,41 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
     @Override
     public Void visitIntersectionType(IntersectionTypeContext stsIntersectionType) {
+        writeLeadingComments(stsIntersectionType);
         sb.append('(');
 
         for (int i = 0; i < stsIntersectionType.getChildCount(); ++i) {
-            // There may be comments among type references here,
-            // each following a type reference that was invalid.
-            // See JavaTransformer.visit(TypeParameter) for details.
             ParseTree stsChildNode = stsIntersectionType.getChild(i);
-            if (stsChildNode instanceof TypeReferenceContext) {
-                if (i > 0) sb.append(" & ");
-                visitTypeReference((TypeReferenceContext) stsChildNode);
-            }
-            else if (stsChildNode instanceof TerminalNode) {
-                visitTerminal((TerminalNode)stsChildNode);
-            }
+
+            if (i > 0) sb.append(" & ");
+            stsChildNode.accept(this);
         }
 
         sb.append(')');
+
+        writeTrailingComments(stsIntersectionType);
         return null;
     }
 
     // typeReference: typeReferencePart (Dot typeReferencePart)?
     @Override
     public Void visitTypeReference(TypeReferenceContext stsTypeReference) {
+        writeLeadingComments(stsTypeReference);
+
         List<TypeReferencePartContext> stsTypeParts = stsTypeReference.typeReferencePart();
         for (int i = 0; i < stsTypeParts.size(); ++i) {
             if (i > 0) sb.append('.');
             visitTypeReferencePart(stsTypeParts.get(i));
         }
 
+        writeTrailingComments(stsTypeReference);
         return null;
     }
 
     // typeReferencePart: qualifiedName typeArguments?
     @Override
     public Void visitTypeReferencePart(TypeReferencePartContext stsTypeReferencePart) {
+        writeLeadingComments(stsTypeReferencePart);
         visitQualifiedName(stsTypeReferencePart.qualifiedName());
 
         TypeArgumentsContext stsTypeArguments = stsTypeReferencePart.typeArguments();
@@ -313,12 +376,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitTypeArguments(stsTypeArguments);
         }
 
+        writeTrailingComments(stsTypeReferencePart);
         return null;
     }
 
     // qualifiedName: Identifier (Dot Identifier)*
     @Override
     public Void visitQualifiedName(QualifiedNameContext stsQualName) {
+        writeLeadingComments(stsQualName);
+
         int i = 0;
         for (TerminalNode identifier : stsQualName.Identifier()) {
             sb.append(identifier.getText());
@@ -326,6 +392,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             ++i;
         }
 
+        writeTrailingComments(stsQualName);
         return null;
     }
 
@@ -343,13 +410,19 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 //    ;
     @Override
     public Void visitPredefinedType(PredefinedTypeContext stsPredefinedType) {
+        writeLeadingComments(stsPredefinedType);
+
         sb.append(stsPredefinedType.getText());
+
+        writeTrailingComments(stsPredefinedType);
         return null;
     }
 
     // arrayType: (predefinedType | typeReference) ('[' ']')+
     @Override
     public Void visitArrayType(ArrayTypeContext stsArrayType) {
+        writeLeadingComments(stsArrayType);
+
         TypeReferenceContext stsTypeRef = stsArrayType.typeReference();
         if (stsTypeRef != null) {
             visitTypeReference(stsTypeRef);
@@ -368,12 +441,14 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         for (int i = 0; i < openBracketsNum; ++i)
             sb.append("[]");
 
+        writeTrailingComments(stsArrayType);
         return null;
     }
 
     // typeAnnotation: ':' primaryType
     @Override
     public Void visitTypeAnnotation(TypeAnnotationContext stsTypeAnnotation) {
+        writeLeadingComments(stsTypeAnnotation);
         sb.append(": ");
 
         PrimaryTypeContext stsType = stsTypeAnnotation.primaryType();
@@ -383,19 +458,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             stsTypeAnnotation.parent.getRuleIndex() != StaticTSParser.RULE_exceptionParameter)
             sb.append(' ');
 
-        // In case of unresolved or invalid type, we add a comment to TypeAnnotationContext
-        // node indicating the original type name where we can (the type itself is emitted as
-        // __UnknownType__, see, e.g., JavaTransformer.createCatchOrRecoverClause method).
-        // Here we check if that additional child of TypeAnnotationContext node exists,
-        // and if so, emit it in STS source code.
-        visitComment(stsTypeAnnotation, 1);
-
+        writeTrailingComments(stsTypeAnnotation);
         return null;
     }
 
     // signature: typeParameters? '(' parameterList? ')' typeAnnotation
     @Override
     public Void visitSignature(SignatureContext stsSignature) {
+        writeLeadingComments(stsSignature);
+
         TypeParametersContext stsTypeParameters = stsSignature.typeParameters();
         if (stsTypeParameters != null) {
             visitTypeParameters(stsTypeParameters);
@@ -415,6 +486,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         if( stsSignature.Throws() != null)
             sb.append(' ').append(stsSignature.Throws().getText()).append(' ');
 
+        writeTrailingComments(stsSignature);
         return null;
     }
 
@@ -423,7 +495,11 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitAccessibilityModifier(AccessibilityModifierContext stsAccessibilityModifier) {
         doNeededIndent();
+        writeLeadingComments(stsAccessibilityModifier);
+
         sb.append(stsAccessibilityModifier.getText()).append(' ');
+
+        writeTrailingComments(stsAccessibilityModifier);
         return null;
     }
 
@@ -431,6 +507,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitConstructorDeclaration(ConstructorDeclarationContext stsConstructorDeclaration) {
         doNeededIndent();
+        writeLeadingComments(stsConstructorDeclaration);
 
         sb.append(stsConstructorDeclaration.Constructor().getText());
 
@@ -459,23 +536,28 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(indentCurrent).append("}\n\n");
 
+        writeTrailingComments(stsConstructorDeclaration);
         return null;
     }
 
     @Override
     public Void visitConstructorBody(ConstructorBodyContext stsConstructorBody) {
+        writeLeadingComments(stsConstructorBody);
+
         ConstructorCallContext stsConstructorCall = stsConstructorBody.constructorCall();
         if (stsConstructorCall != null) visitConstructorCall(stsConstructorCall);
 
         for (StatementOrLocalDeclarationContext stsStatementOrLocalDecl : stsConstructorBody.statementOrLocalDeclaration())
             visitStatementOrLocalDeclaration(stsStatementOrLocalDecl);
 
+        writeTrailingComments(stsConstructorBody);
         return null;
     }
 
     @Override
     public Void visitConstructorCall(ConstructorCallContext stsConstructorCall) {
         doNeededIndent();
+        writeLeadingComments(stsConstructorCall);
 
         TerminalNode term = stsConstructorCall.Try();
         if (term != null) sb.append(term.getText()).append(' ');
@@ -501,14 +583,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(";\n");
 
+        writeTrailingComments(stsConstructorCall);
         return null;
     }
 
-    // interfaceDeclaration: Export? Declare? Interface Identifier typeParameters? interfaceExtendsClause? '{' interfaceBody '}'
     // interfaceDeclaration: accessibilityModifier? Interface Identifier typeParameters? interfaceExtendsClause? '{' interfaceBody '}'
     @Override
     public Void visitInterfaceDeclaration(InterfaceDeclarationContext stsInterfaceDeclaration) {
         doNeededIndent();
+        writeLeadingComments(stsInterfaceDeclaration);
 
         sb.append(stsInterfaceDeclaration.Interface().getText()).append(' ');
         sb.append(stsInterfaceDeclaration.Identifier().getText());
@@ -532,28 +615,39 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(indentCurrent).append("}\n\n");
 
+        writeTrailingComments(stsInterfaceDeclaration);
         return null;
     }
 
     // interfaceBody: interfaceMember+
     @Override
     public Void visitInterfaceBody(InterfaceBodyContext stsInterfaceBody) {
+        writeLeadingComments(stsInterfaceBody);
+
         visitChildren(stsInterfaceBody);
+
+        writeTrailingComments(stsInterfaceBody);
         return null;
     }
 
     // : Identifier signature SemiColon                                           #InterfaceMethod
     @Override
     public Void visitInterfaceMethod(InterfaceMethodContext stsInterfaceMethod) {
+        writeLeadingComments(stsInterfaceMethod);
+
         sb.append(stsInterfaceMethod.Identifier().getText());
         visitSignature(stsInterfaceMethod.signature());
         sb.append(";\n");
+
+        writeTrailingComments(stsInterfaceMethod);
         return null;
     }
 
     // | (Static | Private)? methodSignature block   #InterfaceMethodWithBody
     @Override
     public Void visitInterfaceMethodWithBody(InterfaceMethodWithBodyContext stsInterfaceMethodWithBody) {
+        writeLeadingComments(stsInterfaceMethodWithBody);
+
         modifierWriteSafe(stsInterfaceMethodWithBody.Private());
         modifierWriteSafe(stsInterfaceMethodWithBody.Static());
 
@@ -562,6 +656,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         visitBlock(stsInterfaceMethodWithBody.block());
 
+        writeTrailingComments(stsInterfaceMethodWithBody);
         return null;
     }
 
@@ -569,43 +664,63 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitInterfaceField(InterfaceFieldContext stsInterfaceField) {
         doNeededIndent();
+        writeLeadingComments(stsInterfaceField);
+
         visitConstantDeclaration(stsInterfaceField.constantDeclaration());
         sb.append(";\n");
 
+        writeTrailingComments(stsInterfaceField);
         return null;
     }
 
     // | interfaceDeclaration                                                #InterfaceInInterface
     @Override
     public Void visitInterfaceInInterface(InterfaceInInterfaceContext stsInnerInterface) {
+        writeLeadingComments(stsInnerInterface);
+
         visitInterfaceDeclaration(stsInnerInterface.interfaceDeclaration());
+
+        writeTrailingComments(stsInnerInterface);
         return null;
     }
 
     // | classDeclaration                                                    #ClassInInterface
     @Override
     public Void visitClassInInterface(ClassInInterfaceContext stsInnerClass) {
+        writeLeadingComments(stsInnerClass);
+
         visitClassDeclaration(stsInnerClass.classDeclaration());
+
+        writeTrailingComments(stsInnerClass);
         return null;
     }
 
     @Override
     public Void visitEnumInInterface(EnumInInterfaceContext stsInnerEnum) {
+        writeLeadingComments(stsInnerEnum);
+
         visitEnumDeclaration(stsInnerEnum.enumDeclaration());
+
+        writeTrailingComments(stsInnerEnum);
         return null;
     }
 
     // interfaceExtendsClause: Extends classOrInterfaceTypeList
     @Override
     public Void visitInterfaceExtendsClause(InterfaceExtendsClauseContext stsInterfaceExtendsClause) {
+        writeLeadingComments(stsInterfaceExtendsClause);
+
         sb.append(stsInterfaceExtendsClause.Extends().getText()).append(' ');
         visitInterfaceTypeList(stsInterfaceExtendsClause.interfaceTypeList());
+
+        writeTrailingComments(stsInterfaceExtendsClause);
         return null;
     }
 
     // classOrInterfaceTypeList: typeReference (',' typeReference)*
     @Override
     public Void visitInterfaceTypeList(InterfaceTypeListContext stsClassOrInterfaceTypeList) {
+        writeLeadingComments(stsClassOrInterfaceTypeList);
         int i = 0;
         for (TypeReferenceContext stsTypeReference : stsClassOrInterfaceTypeList.typeReference()) {
             if (i > 0) sb.append(", ");
@@ -613,6 +728,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             ++i;
         }
 
+        writeTrailingComments(stsClassOrInterfaceTypeList);
         return null;
     }
 
@@ -620,6 +736,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitEnumDeclaration(EnumDeclarationContext stsEnumDeclaration) {
         doNeededIndent();
+        writeLeadingComments(stsEnumDeclaration);
+
         sb.append(stsEnumDeclaration.Enum().getText()).append(' ');
         sb.append(stsEnumDeclaration.Identifier().getText());
 
@@ -636,12 +754,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(indentCurrent).append("}\n");
 
+        writeTrailingComments(stsEnumDeclaration);
         return null;
     }
 
     // enumBody: enumMember (',' enumMember)*
     @Override
     public Void visitEnumBody(EnumBodyContext stsEnumBody) {
+        writeLeadingComments(stsEnumBody);
+
         boolean isFirstMember = true;
         for (EnumMemberContext stsEnumMember : stsEnumBody.enumMember()) {
             if (!isFirstMember) {
@@ -654,12 +775,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitEnumMember(stsEnumMember);
         }
 
+        writeTrailingComments(stsEnumBody);
         return null;
     }
 
     // enumMember: Identifier ('=' singleExpression)?
     @Override
     public Void visitEnumMember(EnumMemberContext stsEnumMember) {
+        writeLeadingComments(stsEnumMember);
+
         sb.append(stsEnumMember.Identifier().getText());
 
         SingleExpressionContext stsInitializer = stsEnumMember.singleExpression();
@@ -668,12 +792,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             stsInitializer.accept(this);
         }
 
+        writeTrailingComments(stsEnumMember);
         return null;
     }
 
     // compilationUnit: packageDeclaration? importStatement* topDeclaration* EOF;
     @Override
     public Void visitCompilationUnit(CompilationUnitContext stsCompilationUnit) {
+        writeLeadingComments(stsCompilationUnit);
+
         PackageDeclarationContext stsPackageDecl = stsCompilationUnit.packageDeclaration();
         if (stsPackageDecl != null) visitPackageDeclaration(stsPackageDecl);
 
@@ -685,11 +812,17 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             stsTopDeclaration.accept(this);
         }
 
+        // trailing comments may be present as
+        // comments that weren't picked up by the
+        // last top declaration.
+        writeTrailingComments(stsCompilationUnit);
         return null;
     }
 
     @Override
     public Void visitTopDeclaration(TopDeclarationContext stsTopDeclaration) {
+        writeLeadingComments(stsTopDeclaration);
+
         int declIndex = 0;
         TerminalNode termExport = stsTopDeclaration.Export();
         if (termExport != null) {
@@ -699,15 +832,19 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         assert(stsTopDeclaration.getChildCount() == declIndex+1);
         stsTopDeclaration.getChild(declIndex).accept(this);
 
+        writeTrailingComments(stsTopDeclaration);
         return null;
     }
 
     @Override
     public Void visitPackageDeclaration(PackageDeclarationContext stsPackageDecl) {
+        writeLeadingComments(stsPackageDecl);
+
         sb.append(stsPackageDecl.Package().getText()).append(' ');
         visitQualifiedName(stsPackageDecl.qualifiedName());
         sb.append(";\n\n");
 
+        writeTrailingComments(stsPackageDecl);
         return null;
     }
 
@@ -728,9 +865,12 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitStatement(StatementContext stsStatement) {
         doNeededIndent();
+        writeLeadingComments(stsStatement);
 
         assert(stsStatement.getChildCount() == 1);
         stsStatement.getChild(0).accept(this);
+
+        writeTrailingComments(stsStatement);
         return null;
     }
 
@@ -738,6 +878,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitBlock(BlockContext stsBlock) {
         doNeededIndent();
+        writeLeadingComments(stsBlock);
+
         sb.append("{\n");
         indentIncrement();
 
@@ -749,12 +891,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         indentDecrement();
         sb.append(indentCurrent).append("}\n");
 
+        writeTrailingComments(stsBlock);
         return null;
     }
 
     // importDeclaration: Import qualifiedName (Dot Multiply)? SemiColon?
     public Void visitImportDeclaration(ImportDeclarationContext stsImportDeclaration) {
         doNeededIndent();
+        writeLeadingComments(stsImportDeclaration);
+
         sb.append(stsImportDeclaration.Import().getText()).append(' ');
 
         visitQualifiedName(stsImportDeclaration.qualifiedName());
@@ -775,11 +920,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         }
 
         sb.append(";\n");
+
+        writeTrailingComments(stsImportDeclaration);
         return null;
     }
 
     @Override
     public Void visitAssertStatement(AssertStatementContext stsAssertStatement) {
+        writeLeadingComments(stsAssertStatement);
+
         TerminalNode termAssert = stsAssertStatement.Assert();
         sb.append(termAssert.getText()).append(' ');
 
@@ -792,6 +941,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         }
 
         sb.append(";\n");
+
+        writeTrailingComments(stsAssertStatement);
         return null;
     }
 
@@ -799,6 +950,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitVariableOrConstantDeclaration(VariableOrConstantDeclarationContext stsVarOrConstDeclaration) {
         doNeededIndent();
+        writeLeadingComments(stsVarOrConstDeclaration);
 
         TerminalNode termLet = stsVarOrConstDeclaration.Let();
         if (termLet != null) {
@@ -813,24 +965,31 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(";\n");
 
+        writeTrailingComments(stsVarOrConstDeclaration);
         return null;
     }
 
     // variableDeclarationList: variableDeclaration (',' variableDeclaration)*
     @Override
     public Void visitVariableDeclarationList(VariableDeclarationListContext stsVariableDeclarationList) {
+        writeLeadingComments(stsVariableDeclarationList);
+
         int i = 0;
         for (VariableDeclarationContext stsVariableDeclaration : stsVariableDeclarationList.variableDeclaration()) {
             if (i > 0) sb.append(", ");
             visitVariableDeclaration(stsVariableDeclaration);
             ++i;
         }
+
+        writeTrailingComments(stsVariableDeclarationList);
         return null;
     }
 
     // constantDeclarationList: constantDeclaration (',' constantDeclaration)*
     @Override
     public Void visitConstantDeclarationList(ConstantDeclarationListContext stsConstantDeclarationList) {
+        writeLeadingComments(stsConstantDeclarationList);
+
         int i = 0;
         for (ConstantDeclarationContext stsConstantDeclaration : stsConstantDeclarationList.constantDeclaration()) {
             if (i > 0) sb.append(", ");
@@ -838,12 +997,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             ++i;
         }
 
+        writeTrailingComments(stsConstantDeclarationList);
         return null;
     }
 
     // variableDeclaration    : Identifier typeAnnotation initializer? | Identifier initializer
     @Override
     public Void visitVariableDeclaration(VariableDeclarationContext stsVariableDeclaration) {
+        writeLeadingComments(stsVariableDeclaration);
+
         sb.append(stsVariableDeclaration.Identifier().getText()).append(' ');
 
         TypeAnnotationContext stsTypeAnnotation = stsVariableDeclaration.typeAnnotation();
@@ -856,12 +1018,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitInitializer(stsInitializer);
         }
 
+        writeTrailingComments(stsVariableDeclaration);
         return null;
     }
 
     // constantDeclaration: Identifier typeAnnotation? initializer
     @Override
     public Void visitConstantDeclaration(ConstantDeclarationContext stsConstantDeclaration) {
+        writeLeadingComments(stsConstantDeclaration);
+
         TerminalNode termIdentifier = stsConstantDeclaration.Identifier();
         sb.append(termIdentifier.getText()).append(' ');
 
@@ -875,6 +1040,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitInitializer(stsInitializer);
         }
 
+        writeTrailingComments(stsConstantDeclaration);
         return null;
     }
 
@@ -882,9 +1048,12 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitExpressionStatement(ExpressionStatementContext stsExpressionStatement) {
         doNeededIndent();
+        writeLeadingComments(stsExpressionStatement);
+
         stsExpressionStatement.singleExpression().accept(this);
         sb.append(";\n");
 
+        writeTrailingComments(stsExpressionStatement);
         return null;
     }
 
@@ -892,6 +1061,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitIfStatement(IfStatementContext stsIfStatement) {
         doNeededIndent();
+        writeLeadingComments(stsIfStatement);
+
         sb.append(stsIfStatement.If().getText()).append(" (");
 
         stsIfStatement.singleExpression().accept(this);
@@ -909,6 +1080,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitStatement(stsIfStatement.elseStmt);
         }
 
+        writeTrailingComments(stsIfStatement);
         return null;
     }
 
@@ -916,6 +1088,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitDoStatement(DoStatementContext stsDoStatement) {
         doNeededIndent();
+        writeLeadingComments(stsDoStatement);
+
         sb.append(stsDoStatement.Do().getText()).append("\n");
 
         StatementContext stsStmt = stsDoStatement.statement();
@@ -928,6 +1102,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(");\n");
 
+        writeTrailingComments(stsDoStatement);
         return null;
     }
 
@@ -935,6 +1110,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitWhileStatement(WhileStatementContext stsWhileStatement) {
         doNeededIndent();
+        writeLeadingComments(stsWhileStatement);
+
         sb.append(stsWhileStatement.While().getText()).append('(');
         stsWhileStatement.singleExpression().accept(this);
         sb.append(")\n");
@@ -943,6 +1120,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         assert (stsStmt != null);
         visitStatement(stsStmt);
 
+        writeTrailingComments(stsWhileStatement);
         return null;
     }
 
@@ -950,6 +1128,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitForStatement(ForStatementContext stsForStatement) {
         doNeededIndent();
+        writeLeadingComments(stsForStatement);
+
         sb.append(stsForStatement.For().getText()).append(" (");
 
         ForInitContext stsForInit = stsForStatement.forInit();
@@ -977,12 +1157,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         assert(stsStmt != null);
         visitStatement(stsStmt);
 
+        writeTrailingComments(stsForStatement);
         return null;
     }
 
     // forInit: ExpressionSequence | Let variableDeclarationList
     @Override
     public Void visitForInit(ForInitContext stsForInit) {
+        writeLeadingComments(stsForInit);
+
         ExpressionSequenceContext stsExprSeq = stsForInit.expressionSequence();
         if (stsExprSeq != null) {
             visitExpressionSequence(stsExprSeq);
@@ -991,12 +1174,14 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitVariableDeclarationList(stsForInit.variableDeclarationList());
         }
 
+        writeTrailingComments(stsForInit);
         return null;
     }
 
     // expressionSequence: singleExpression (',' singleExpression)*
     @Override
     public Void visitExpressionSequence(ExpressionSequenceContext stsExpressionSequence) {
+        writeLeadingComments(stsExpressionSequence);
         int i = 0;
         for (SingleExpressionContext stsExpression : stsExpressionSequence.singleExpression()) {
             if (i > 0) sb.append(", ");
@@ -1004,13 +1189,16 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             ++i;
         }
 
-       return null;
+        writeTrailingComments(stsExpressionSequence);
+        return null;
     }
 
      // | For '(' Let Identifier typeAnnotation? Of singleExpression ')' (statement | block)  # ForInOfStatement
     @Override
     public Void visitForOfStatement(ForOfStatementContext stsForOfStatement) {
         doNeededIndent();
+        writeLeadingComments(stsForOfStatement);
+
         sb.append(stsForOfStatement.For().getText()).append(" (");
         sb.append(stsForOfStatement.Let().getText()).append(' ');
         sb.append(stsForOfStatement.Identifier().getText()).append(' ');
@@ -1030,6 +1218,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         assert(stsStmt != null);
         visitStatement(stsStmt);
 
+        writeTrailingComments(stsForOfStatement);
         return null;
     }
 
@@ -1037,6 +1226,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitContinueStatement(ContinueStatementContext stsContinueStatement) {
         doNeededIndent();
+        writeLeadingComments(stsContinueStatement);
+
         sb.append(stsContinueStatement.Continue().getText());
 
         TerminalNode termIdentifier = stsContinueStatement.Identifier();
@@ -1046,6 +1237,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(";\n");
 
+        writeTrailingComments(stsContinueStatement);
         return null;
     }
 
@@ -1053,6 +1245,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitBreakStatement(BreakStatementContext stsBreakStatement) {
         doNeededIndent();
+        writeLeadingComments(stsBreakStatement);
+
         sb.append(stsBreakStatement.Break().getText());
 
         TerminalNode termIdentifier = stsBreakStatement.Identifier();
@@ -1062,6 +1256,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(";\n");
 
+        writeTrailingComments(stsBreakStatement);
         return null;
     }
 
@@ -1069,6 +1264,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitReturnStatement(ReturnStatementContext stsReturnStatement) {
         doNeededIndent();
+        writeLeadingComments(stsReturnStatement);
+
         sb.append(stsReturnStatement.Return().getText());
 
         SingleExpressionContext stsSingleExpression = stsReturnStatement.singleExpression();
@@ -1079,12 +1276,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(";\n");
 
+        writeTrailingComments(stsReturnStatement);
         return null;
     }
 
     //    | (typeReference Dot)? This  # ThisExpression
     @Override
     public Void visitThisExpression(ThisExpressionContext stsThisExpression) {
+        writeLeadingComments(stsThisExpression);
+
         TypeReferenceContext stsTypeReference = stsThisExpression.typeReference();
         if (stsTypeReference != null) {
             visitTypeReference(stsTypeReference);
@@ -1092,19 +1292,27 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         }
 
         sb.append(stsThisExpression.This().getText());
+
+        writeTrailingComments(stsThisExpression);
         return null;
     }
 
     //    | Identifier                                                             # IdentifierExpression
     @Override
     public Void visitIdentifierExpression(IdentifierExpressionContext stsIdentifierExpression) {
+        writeLeadingComments(stsIdentifierExpression);
+
         sb.append(stsIdentifierExpression.Identifier().getText());
+
+        writeTrailingComments(stsIdentifierExpression);
         return null;
     }
 
     //    | (typeReference Dot)? Super # SuperExpression
     @Override
     public Void visitSuperExpression(SuperExpressionContext stsSuperExpression) {
+        writeLeadingComments(stsSuperExpression);
+
         TypeReferenceContext stsTypeReference = stsSuperExpression.typeReference();
         if (stsTypeReference != null) {
             visitTypeReference(stsTypeReference);
@@ -1112,6 +1320,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         }
 
         sb.append(stsSuperExpression.Super().getText());
+
+        writeTrailingComments(stsSuperExpression);
         return null;
     }
 
@@ -1119,6 +1329,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitSwitchStatement(SwitchStatementContext stsSwitchStatement) {
         doNeededIndent();
+        writeLeadingComments(stsSwitchStatement);
 
         sb.append(stsSwitchStatement.Switch().getText()).append(" (");
         stsSwitchStatement.singleExpression().accept(this);
@@ -1127,15 +1338,17 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         visitCaseBlock(stsSwitchStatement.caseBlock());
         sb.append('\n');
 
+        writeTrailingComments(stsSwitchStatement);
         return null;
     }
 
     // caseBlock: '{' leftCases=caseClauses? defaultClause? rightCases=caseClauses? '}'
     @Override
     public Void visitCaseBlock(CaseBlockContext stsCaseBlock) {
-        if (!doNeededIndent()) {
-            sb.append(' ');
-        }
+        boolean needSpace = !doNeededIndent();
+        writeLeadingComments(stsCaseBlock);
+
+        if (needSpace) sb.append(' ');
 
         sb.append("{\n");
         indentIncrement();
@@ -1156,17 +1369,21 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         indentDecrement();
         sb.append(indentCurrent).append("}\n");
 
+        writeTrailingComments(stsCaseBlock);
         return null;
     }
 
     // caseClauses: caseClause+
     @Override
     public Void visitCaseClauses(CaseClausesContext stsCaseClauses) {
+        writeLeadingComments(stsCaseClauses);
+
         List<CaseClauseContext> stsCaseClauseList = stsCaseClauses.caseClause();
         for (CaseClauseContext stsCaseClause : stsCaseClauseList) {
             visitCaseClause(stsCaseClause);
         }
 
+        writeTrailingComments(stsCaseClauses);
         return null;
     }
 
@@ -1174,6 +1391,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitCaseClause(CaseClauseContext stsCaseClause) {
         doNeededIndent();
+        writeLeadingComments(stsCaseClause);
+
         sb.append(stsCaseClause.Case().getText()).append(' ');
         stsCaseClause.singleExpression().accept(this);
         sb.append(":\n");
@@ -1185,6 +1404,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitStatement(stsStatement);
         indentDecrement();
 
+        writeTrailingComments(stsCaseClause);
         return null;
     }
 
@@ -1192,6 +1412,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitDefaultClause(DefaultClauseContext stsDefaultClause) {
         doNeededIndent();
+        writeLeadingComments(stsDefaultClause);
+
         sb.append(stsDefaultClause.Default().getText()).append(":\n");
 
         List<StatementContext> stsStatementList = stsDefaultClause.statement();
@@ -1201,6 +1423,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitStatement(stsStatement);
         indentDecrement();
 
+        writeTrailingComments(stsDefaultClause);
         return null;
     }
 
@@ -1208,12 +1431,14 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitLabelledStatement(LabelledStatementContext stsLabelledStatement) {
         doNeededIndent();
+        writeLeadingComments(stsLabelledStatement);
+
         sb.append(stsLabelledStatement.Identifier().getText()).append(": ");
         // after removing Block node from statements we got hanging labels before java blocks
         if( stsLabelledStatement.statement() !=null )
             visitStatement(stsLabelledStatement.statement());
 
-
+        writeTrailingComments(stsLabelledStatement);
         return null;
     }
 
@@ -1221,20 +1446,26 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitThrowStatement(ThrowStatementContext stsThrowStatement) {
         doNeededIndent();
+        writeLeadingComments(stsThrowStatement);
+
         sb.append(stsThrowStatement.Throw().getText()).append(' ');
         stsThrowStatement.singleExpression().accept(this);
         sb.append(";\n");
 
+        writeTrailingComments(stsThrowStatement);
         return null;
     }
 
     @Override
     public Void visitPanicStatement(PanicStatementContext stsPanicStatement) {
         doNeededIndent();
+        writeLeadingComments(stsPanicStatement);
+
         sb.append(stsPanicStatement.Panic().getText()).append(' ');
         stsPanicStatement.singleExpression().accept(this);
         sb.append(";\n");
 
+        writeTrailingComments(stsPanicStatement);
         return null;
     }
 
@@ -1242,6 +1473,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitTrapStatement(TrapStatementContext stsTrapStatement) {
         doNeededIndent();
+        writeLeadingComments(stsTrapStatement);
+
         sb.append(stsTrapStatement.Trap().getText()).append(' ');
 
         visitBlock(stsTrapStatement.block());
@@ -1253,6 +1486,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         }
 
         sb.append('\n');
+
+        writeTrailingComments(stsTrapStatement);
         return null;
     }
 
@@ -1261,6 +1496,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitCatchOrRecoverClause(CatchOrRecoverClauseContext stsCatchOrRecoverClause) {
         doNeededIndent();
+        writeLeadingComments(stsCatchOrRecoverClause);
 
         TerminalNode stsTerm = stsCatchOrRecoverClause.Catch();
         if (stsTerm == null) stsTerm = stsCatchOrRecoverClause.Recover();
@@ -1276,15 +1512,19 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         assert(stsBlock != null);
         visitBlock(stsBlock);
 
+        writeTrailingComments(stsCatchOrRecoverClause);
         return null;
     }
 
     @Override
     public Void visitExceptionParameter(ExceptionParameterContext stsExceptionParam) {
+        writeLeadingComments(stsExceptionParam);
+
         sb.append('(').append(stsExceptionParam.Identifier().getText()).append(' ');
         visitTypeAnnotation(stsExceptionParam.typeAnnotation());
         sb.append(") ");
 
+        writeTrailingComments(stsExceptionParam);
         return null;
     }
 
@@ -1292,6 +1532,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitFunctionDeclaration(FunctionDeclarationContext stsFunctionDeclaration) {
         doNeededIndent();
+        writeLeadingComments(stsFunctionDeclaration);
+
         sb.append(stsFunctionDeclaration.Function().getText()).append(' ');
         sb.append(stsFunctionDeclaration.Identifier().getText());
 
@@ -1299,6 +1541,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         visitBlock(stsFunctionDeclaration.block());
 
+        writeTrailingComments(stsFunctionDeclaration);
         return null;
     }
 
@@ -1313,6 +1556,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitClassDeclaration(ClassDeclarationContext stsClassDeclaration) {
         doNeededIndent();
+        writeLeadingComments(stsClassDeclaration);
 
         modifierWriteSafe(stsClassDeclaration.Abstract());
         modifierWriteSafe(stsClassDeclaration.Static());
@@ -1341,12 +1585,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         visitClassBody(stsClassDeclaration.classBody());
 
+        writeTrailingComments(stsClassDeclaration);
         return null;
     }
 
     // classBody:  '{' classElement* '}'
     @Override
     public Void visitClassBody(ClassBodyContext stsClassBody) {
+        writeLeadingComments(stsClassBody);
+
         sb.append(" {\n");
         indentIncrement();
 
@@ -1360,6 +1607,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             !(stsClassBody.getParent() instanceof NewInnerClassInstanceExpressionContext))
             sb.append("\n\n");
 
+        writeTrailingComments(stsClassBody);
         return null;
     }
 
@@ -1367,6 +1615,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitClassInitializer(ClassInitializerContext stsClassInit) {
         doNeededIndent();
+        writeLeadingComments(stsClassInit);
 
         modifierWriteSafe(stsClassInit.Static());
 
@@ -1374,6 +1623,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         assert(stsBlock != null);
         visitBlock(stsBlock);
 
+        writeTrailingComments(stsClassInit);
         return null;
     }
 
@@ -1383,6 +1633,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitClassFieldDeclaration(ClassFieldDeclarationContext stsClassField) {
         doNeededIndent();
+        writeLeadingComments(stsClassField);
 
         modifierWriteSafe(stsClassField.Static());
 
@@ -1401,6 +1652,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(";\n");
 
+        writeTrailingComments(stsClassField);
         return null;
     }
 
@@ -1408,6 +1660,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitClassMethodWithBody(ClassMethodWithBodyContext stsClassMethodWithBody) {
         doNeededIndent();
+        writeLeadingComments(stsClassMethodWithBody);
 
         modifierWriteSafe(stsClassMethodWithBody.Static());
         modifierWriteSafe(stsClassMethodWithBody.Override());
@@ -1418,6 +1671,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         visitBlock(stsClassMethodWithBody.block());
 
+        writeTrailingComments(stsClassMethodWithBody);
         return null;
     }
 
@@ -1425,6 +1679,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitAbstractOrNativeClassMethod(AbstractOrNativeClassMethodContext stsAbstractMethod) {
         doNeededIndent();
+        writeLeadingComments(stsAbstractMethod);
 
         modifierWriteSafe(stsAbstractMethod.Abstract());
         modifierWriteSafe(stsAbstractMethod.Static());
@@ -1435,24 +1690,33 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(";\n");
 
+        writeTrailingComments(stsAbstractMethod);
         return null;
     }
 
     // classExtendsClause: Extends typeReference
     @Override
     public Void visitClassExtendsClause(ClassExtendsClauseContext stsClassExtendsClause) {
+        writeLeadingComments(stsClassExtendsClause);
+
         sb.append(stsClassExtendsClause.Extends().getText()).append(' ');
         visitTypeReference(stsClassExtendsClause.typeReference());
         sb.append(' ');
+
+        writeTrailingComments(stsClassExtendsClause);
         return null;
     }
 
     // implementsClause: Implements classOrInterfaceTypeList
     @Override
     public Void visitImplementsClause(ImplementsClauseContext stsImplementsClause) {
+        writeLeadingComments(stsImplementsClause);
+
         sb.append(stsImplementsClause.Implements().getText()).append(' ');
         visitInterfaceTypeList(stsImplementsClause.interfaceTypeList());
         sb.append(' ');
+
+        writeTrailingComments(stsImplementsClause);
         return null;
     }
 
@@ -1461,6 +1725,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     //    | variadicParameter
     @Override
     public Void visitParameterList(ParameterListContext stsParameterList) {
+        writeLeadingComments(stsParameterList);
         List<ParameterContext> stsParameters = stsParameterList.parameter();
 
         int i = 0;
@@ -1478,12 +1743,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitVariadicParameter(stsVariadicParameter);
         }
 
+        writeTrailingComments(stsParameterList);
         return null;
     }
 
     // parameter: Identifier typeAnnotation
     @Override
     public Void visitParameter(ParameterContext stsParameter) {
+        writeLeadingComments(stsParameter);
+
         TerminalNode termIdentifier = stsParameter.Identifier();
         if (termIdentifier != null) {
             sb.append(termIdentifier.getText()).append(' ');
@@ -1491,21 +1759,28 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         visitTypeAnnotation(stsParameter.typeAnnotation());
 
+        writeTrailingComments(stsParameter);
         return null;
     }
 
     // variadicParameter: Ellipsis Identifier typeAnnotation
     @Override
     public Void visitVariadicParameter(VariadicParameterContext stsVariadicParameter) {
+        writeLeadingComments(stsVariadicParameter);
+
         sb.append(stsVariadicParameter.Ellipsis().getText()).append(' ');
         sb.append(stsVariadicParameter.Identifier().getText());
         visitTypeAnnotation(stsVariadicParameter.typeAnnotation());
+
+        writeTrailingComments(stsVariadicParameter);
         return null;
     }
 
     // | OpenBracket expressionSequence? CloseBracket  #ArrayLiterlaExpression
     @Override
     public Void visitArrayLiteralExpression(ArrayLiteralExpressionContext stsArrayLiteral) {
+        writeLeadingComments(stsArrayLiteral);
+
         sb.append('[');
 
         ExpressionSequenceContext stsExpressions = stsArrayLiteral.expressionSequence();
@@ -1513,29 +1788,40 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(']');
 
+        writeTrailingComments(stsArrayLiteral);
         return null;
     }
 
     //     | primaryType '.' Class                                                  # ClassLiteralExpression
     @Override
     public Void visitClassLiteralExpression(ClassLiteralExpressionContext stsClassLiteral) {
+        writeLeadingComments(stsClassLiteral);
+
         stsClassLiteral.primaryType().accept(this);
         sb.append(stsClassLiteral.Dot().getText()).append(stsClassLiteral.Class().getText());
+
+        writeTrailingComments(stsClassLiteral);
         return null;
     }
 
     //    | '(' singleExpression ')'                                             # ParenthesizedExpression
     @Override
     public Void visitParenthesizedExpression(ParenthesizedExpressionContext stsParenthesizedExpression) {
+        writeLeadingComments(stsParenthesizedExpression);
+
         sb.append('(');
         stsParenthesizedExpression.singleExpression().accept(this);
         sb.append(')');
+
+        writeTrailingComments(stsParenthesizedExpression);
         return null;
     }
 
     //    | singleExpression As asExpression                                       # CastAsExpression;
     @Override
     public Void visitCastExpression(CastExpressionContext stsCastExpression) {
+        writeLeadingComments(stsCastExpression);
+
         stsCastExpression.singleExpression().accept(this);
 
         sb.append(' ').append(stsCastExpression.As().getText()).append(' ');
@@ -1550,22 +1836,23 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             stsPrimaryType.accept(this);
         }
 
+        writeTrailingComments(stsCastExpression);
         return null;
     }
 
     // arguments: '(' argumentList? ')'
     @Override
     public Void visitArguments(ArgumentsContext stsArguments) {
+        writeLeadingComments(stsArguments);
+
         sb.append('(');
 
         ExpressionSequenceContext stsArgumentList = stsArguments.expressionSequence();
-        if (stsArgumentList != null)
-            visitExpressionSequence(stsArgumentList);
-        else if (stsArguments.getChildCount() > 0)
-            visitChildren(stsArguments);
+        if (stsArgumentList != null) visitExpressionSequence(stsArgumentList);
 
         sb.append(')');
 
+        writeTrailingComments(stsArguments);
         return null;
     }
 
@@ -1583,10 +1870,13 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     //    | singleExpression Instanceof singleExpression                           # InstanceofExpression
     @Override
     public Void visitInstanceofExpression(InstanceofExpressionContext stsInstanceofExpression) {
+        writeLeadingComments(stsInstanceofExpression);
+
         stsInstanceofExpression.singleExpression().accept(this);
         sb.append(' ').append(stsInstanceofExpression.Instanceof().getText()).append(' ');
         stsInstanceofExpression.primaryType().accept(this);
 
+        writeTrailingComments(stsInstanceofExpression);
         return null;
     }
 
@@ -1609,6 +1899,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     // | singleExpression typeArguments? arguments #CallExpression
     @Override
     public Void visitCallExpression(CallExpressionContext stsCallExpression) {
+        writeLeadingComments(stsCallExpression);
+
         stsCallExpression.singleExpression().accept(this);
 
         TypeArgumentsContext stsTypeArguments = stsCallExpression.typeArguments();
@@ -1618,12 +1910,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         visitArguments(stsCallExpression.arguments());
 
+        writeTrailingComments(stsCallExpression);
         return null;
     }
 
     // | New typeArguments? typeReference arguments? classBody? # NewClassInstanceExpression
     @Override
     public Void visitNewClassInstanceExpression(NewClassInstanceExpressionContext stsNewClassInstanceExpression) {
+        writeLeadingComments(stsNewClassInstanceExpression);
+
         sb.append(stsNewClassInstanceExpression.New().getText()).append(' ');
 
         TypeArgumentsContext stsTypeArguments = stsNewClassInstanceExpression.typeArguments();
@@ -1641,12 +1936,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitClassBody(stsClassBody);
         }
 
+        writeTrailingComments(stsNewClassInstanceExpression);
         return null;
     }
 
     // | singleExpression Dot New typeArguments? typeReference arguments? classBody? # NewInnerClassInstanceExpression
     @Override
     public Void visitNewInnerClassInstanceExpression(NewInnerClassInstanceExpressionContext stsNewInnerClassInstanceExpression) {
+        writeLeadingComments(stsNewInnerClassInstanceExpression);
+
         SingleExpressionContext stsOuterObject = stsNewInnerClassInstanceExpression.singleExpression();
         stsOuterObject.accept(this);
 
@@ -1667,12 +1965,15 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitClassBody(stsClassBody);
         }
 
+        writeTrailingComments(stsNewInnerClassInstanceExpression);
         return null;
     }
 
     // | New primaryType indexExpression+ (OpenBracket CloseBracket)* # NewArrayExpression
     @Override
     public Void visitNewArrayExpression(NewArrayExpressionContext stsNewArrayExpression) {
+        writeLeadingComments(stsNewArrayExpression);
+
         TerminalNode stsTerm = stsNewArrayExpression.New();
         sb.append(stsTerm.getText()).append(' ');
 
@@ -1692,11 +1993,14 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             }
         }
 
+        writeTrailingComments(stsNewArrayExpression);
         return null;
     }
 
     @Override
     public Void visitIndexExpression(IndexExpressionContext stsIndexExpression) {
+        writeLeadingComments(stsIndexExpression);
+
         sb.append('[');
 
         SingleExpressionContext stsExpression = stsIndexExpression.singleExpression();
@@ -1705,151 +2009,230 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         sb.append(']');
 
+        writeTrailingComments(stsIndexExpression);
         return null;
     }
 
     //  | singleExpression Dot Identifier   # MemberDotExpression
     @Override
     public Void visitMemberAccessExpression(MemberAccessExpressionContext stsMemberAccessExpression) {
+        writeLeadingComments(stsMemberAccessExpression);
+
         stsMemberAccessExpression.singleExpression().accept(this);
         sb.append('.').append(stsMemberAccessExpression.Identifier().getText());
+
+        writeTrailingComments(stsMemberAccessExpression);
         return null;
     }
 
     //    | singleExpression {this.notLineTerminator()}? '--'                      # PostDecreaseExpression
     @Override
     public Void visitPostDecreaseExpression(PostDecreaseExpressionContext stsPostDecreaseExpression) {
+        writeLeadingComments(stsPostDecreaseExpression);
+
         postOperatorExpressionWrite("--", stsPostDecreaseExpression.singleExpression());
+
+        writeTrailingComments(stsPostDecreaseExpression);
         return null;
     }
 
     //    | singleExpression {this.notLineTerminator()}? '++'                      # PostIncrementExpression
     @Override
     public Void visitPostIncrementExpression(PostIncrementExpressionContext stsPostIncrementExpression) {
+        writeLeadingComments(stsPostIncrementExpression);
+
         postOperatorExpressionWrite("++", stsPostIncrementExpression.singleExpression());
+
+        writeTrailingComments(stsPostIncrementExpression);
         return null;
     }
 
     //    | '++' singleExpression                                                  # PreIncrementExpression
     @Override
     public Void visitPreIncrementExpression(PreIncrementExpressionContext stsPreIncrementExpression) {
+        writeLeadingComments(stsPreIncrementExpression);
+
         preOperatorExpressionWrite("++", stsPreIncrementExpression.singleExpression());
+
+        writeTrailingComments(stsPreIncrementExpression);
         return null;
     }
 
     //    | '--' singleExpression                                                  # PreDecreaseExpression
     @Override
     public Void visitPreDecreaseExpression(PreDecreaseExpressionContext stsPreDecreaseExpression) {
+        writeLeadingComments(stsPreDecreaseExpression);
+
         preOperatorExpressionWrite("--", stsPreDecreaseExpression.singleExpression());
+
+        writeTrailingComments(stsPreDecreaseExpression);
         return null;
     }
 
     //    | '+' singleExpression                                                   # UnaryPlusExpression
     @Override
     public Void visitUnaryPlusExpression(UnaryPlusExpressionContext stsUnaryPlusExpression) {
+        writeLeadingComments(stsUnaryPlusExpression);
+
         preOperatorExpressionWrite("+", stsUnaryPlusExpression.singleExpression());
+
+        writeTrailingComments(stsUnaryPlusExpression);
         return null;
     }
 
     //    | '-' singleExpression                                                   # UnaryMinusExpression
     @Override
     public Void visitUnaryMinusExpression(UnaryMinusExpressionContext stsUnaryMinusExpression) {
+        writeLeadingComments(stsUnaryMinusExpression);
+
         preOperatorExpressionWrite("-", stsUnaryMinusExpression.singleExpression());
+
+        writeTrailingComments(stsUnaryMinusExpression);
         return null;
     }
 
     //    | '~' singleExpression                                                   # BitNotExpression
     @Override
     public Void visitBitNotExpression(BitNotExpressionContext stsBitNotExpression) {
+        writeLeadingComments(stsBitNotExpression);
+
         preOperatorExpressionWrite("~", stsBitNotExpression.singleExpression());
+
+        writeTrailingComments(stsBitNotExpression);
         return null;
     }
 
     //    | '!' singleExpression                                                   # NotExpression
     @Override
     public Void visitNotExpression(NotExpressionContext stsNotExpression) {
+        writeLeadingComments(stsNotExpression);
+
         preOperatorExpressionWrite("!", stsNotExpression.singleExpression());
+
+        writeTrailingComments(stsNotExpression);
         return null;
     }
 
     //    | singleExpression ('*' | '/' | '%') singleExpression                    # MultiplicativeExpression
     @Override
     public Void visitMultiplicativeExpression(MultiplicativeExpressionContext stsMultiplicativeExpression) {
+        writeLeadingComments(stsMultiplicativeExpression);
+
         String op = stsMultiplicativeExpression.getChild(1).getText();
         binaryOperatorWrite(op, stsMultiplicativeExpression.singleExpression());
+
+        writeTrailingComments(stsMultiplicativeExpression);
         return null;
     }
 
     //    | singleExpression ('+' | '-') singleExpression                          # AdditiveExpression
     @Override
     public Void visitAdditiveExpression(AdditiveExpressionContext stsAdditiveExpression) {
+        writeLeadingComments(stsAdditiveExpression);
+
         String op = stsAdditiveExpression.getChild(1).getText();
         binaryOperatorWrite(op, stsAdditiveExpression.singleExpression());
+
+        writeTrailingComments(stsAdditiveExpression);
         return null;
     }
 
     //    | singleExpression ('<' '<' | '>' '>' | '>' '>' '>') singleExpression                # BitShiftExpression
     @Override
     public Void visitBitShiftExpression(BitShiftExpressionContext stsBitShiftExpression) {
+        writeLeadingComments(stsBitShiftExpression);
+
         String op = stsBitShiftExpression.shiftOperator().getText();
         binaryOperatorWrite(op, stsBitShiftExpression.singleExpression());
+
+        writeTrailingComments(stsBitShiftExpression);
         return null;
     }
 
     //    | singleExpression ('<' | '>' | '<=' | '>=') singleExpression            # RelationalExpression
     @Override
     public Void visitRelationalExpression(RelationalExpressionContext stsRelationalExpression) {
+        writeLeadingComments(stsRelationalExpression);
+
         String op = stsRelationalExpression.getChild(1).getText();
         binaryOperatorWrite(op, stsRelationalExpression.singleExpression());
+
+        writeTrailingComments(stsRelationalExpression);
         return null;
     }
 
     // | singleExpression ('==' | '!=') singleExpression                        # EqualityExpression
     @Override
     public Void visitEqualityExpression(EqualityExpressionContext stsEqualityExpression) {
+        writeLeadingComments(stsEqualityExpression);
+
         String op = stsEqualityExpression.getChild(1).getText();
         binaryOperatorWrite(op, stsEqualityExpression.singleExpression());
+
+        writeTrailingComments(stsEqualityExpression);
         return null;
     }
 
     //    | singleExpression '&' singleExpression                                  # BitAndExpression
     @Override
     public Void visitBitAndExpression(BitAndExpressionContext stsBitAndExpression) {
+        writeLeadingComments(stsBitAndExpression);
+
         binaryOperatorWrite(stsBitAndExpression.BitAnd().getText(), stsBitAndExpression.singleExpression());
+
+        writeTrailingComments(stsBitAndExpression);
         return null;
     }
 
     //    | singleExpression '&' singleExpression                                  # BitAndExpression
     @Override
     public Void visitBitXOrExpression(BitXOrExpressionContext stsBitXOrExpression) {
+        writeLeadingComments(stsBitXOrExpression);
+
         binaryOperatorWrite(stsBitXOrExpression.BitXor().getText(), stsBitXOrExpression.singleExpression());
+
+        writeTrailingComments(stsBitXOrExpression);
         return null;
     }
 
     //    | singleExpression '|' singleExpression                                  # BitOrExpression
     @Override
     public Void visitBitOrExpression(BitOrExpressionContext stsBitOrExpression) {
+        writeLeadingComments(stsBitOrExpression);
+
         binaryOperatorWrite(stsBitOrExpression.BitOr().getText(), stsBitOrExpression.singleExpression());
+
+        writeTrailingComments(stsBitOrExpression);
         return null;
     }
 
     //    | singleExpression '&&' singleExpression                                 # LogicalAndExpression
     @Override
     public Void visitLogicalAndExpression(LogicalAndExpressionContext stsLogicalAndExpression) {
+        writeLeadingComments(stsLogicalAndExpression);
+
         binaryOperatorWrite(stsLogicalAndExpression.And().getText(), stsLogicalAndExpression.singleExpression());
+
+        writeTrailingComments(stsLogicalAndExpression);
         return null;
     }
 
     //    | singleExpression '||' singleExpression                                 # LogicalOrExpression
     @Override
     public Void visitLogicalOrExpression(LogicalOrExpressionContext stsLogicalOrExpression) {
+        writeLeadingComments(stsLogicalOrExpression);
+
         binaryOperatorWrite(stsLogicalOrExpression.Or().getText(), stsLogicalOrExpression.singleExpression());
+
+        writeTrailingComments(stsLogicalOrExpression);
         return null;
     }
 
     //    | singleExpression '?' singleExpression ':' singleExpression             # TernaryExpression
     @Override
     public Void visitTernaryExpression(TernaryExpressionContext stsTernaryExpression) {
+        writeLeadingComments(stsTernaryExpression);
+
         List<SingleExpressionContext> stsExpressionList = stsTernaryExpression.singleExpression();
 
         stsExpressionList.get(0).accept(this);
@@ -1858,39 +2241,53 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
         sb.append(" : ");
         stsExpressionList.get(2).accept(this);
 
+        writeTrailingComments(stsTernaryExpression);
         return null;
     }
 
     //    | singleExpression '=' singleExpression                                  # AssignmentExpression
     @Override
-    public Void visitAssignmentExpression(AssignmentExpressionContext sstAssignmentExpression) {
-        binaryOperatorWrite(sstAssignmentExpression.Assign().getText(), sstAssignmentExpression.singleExpression());
+    public Void visitAssignmentExpression(AssignmentExpressionContext stsAssignmentExpression) {
+        writeLeadingComments(stsAssignmentExpression);
+
+        binaryOperatorWrite(stsAssignmentExpression.Assign().getText(), stsAssignmentExpression.singleExpression());
+
+        writeTrailingComments(stsAssignmentExpression);
         return null;
     }
 
     //    | singleExpression assignmentOperator singleExpression                   # AssignmentOperatorExpression
     @Override
     public Void visitAssignmentOperatorExpression(AssignmentOperatorExpressionContext stsAssignmentOperatorExpression) {
+        writeLeadingComments(stsAssignmentOperatorExpression);
+
         String op = stsAssignmentOperatorExpression.assignmentOperator().getText();
         binaryOperatorWrite(op, stsAssignmentOperatorExpression.singleExpression());
+
+        writeTrailingComments(stsAssignmentOperatorExpression);
         return null;
     }
 
         //    | singleExpression '[' indexExpression ']' # ArrayAccessExpression
     @Override
     public Void visitArrayAccessExpression(ArrayAccessExpressionContext stsArrayAccessExpression) {
+        writeLeadingComments(stsArrayAccessExpression);
+
         stsArrayAccessExpression.singleExpression().accept(this);
 
         IndexExpressionContext stsIndexExpression = stsArrayAccessExpression.indexExpression();
         assert(stsIndexExpression != null);
         visitIndexExpression(stsIndexExpression);
 
+        writeTrailingComments(stsArrayAccessExpression);
         return null;
     }
 
     // lambdaExpression: : '(' formalParameterList? ')' typeAnnotation Arrow lambdaBody           # LambdaExpression   // ECMAScript 6
     @Override
     public Void visitLambdaExpression(LambdaExpressionContext stsLambdaExpression) {
+        writeLeadingComments(stsLambdaExpression);
+
         sb.append('(');
         ParameterListContext stsParameterList = stsLambdaExpression.parameterList();
         if (stsParameterList != null) {
@@ -1904,6 +2301,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
 
         visitLambdaBody(stsLambdaExpression.lambdaBody());
 
+        writeTrailingComments(stsLambdaExpression);
         return null;
     }
 
@@ -1912,6 +2310,8 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     //    | '{' functionBody '}'
     @Override
     public Void visitLambdaBody(LambdaBodyContext stsLambdaBody) {
+        writeLeadingComments(stsLambdaBody);
+
         SingleExpressionContext stsSingleExpression = stsLambdaBody.singleExpression();
         if (stsSingleExpression != null) {
             stsSingleExpression.accept(this);
@@ -1927,6 +2327,7 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
             visitBlock(stsBlock);
         }
 
+        writeTrailingComments(stsLambdaBody);
         return null;
     }
 
@@ -1937,8 +2338,11 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     //  | numericLiteral
     @Override
     public Void visitLiteral(LiteralContext stsLiteral) {
+        writeLeadingComments(stsLiteral);
+
         sb.append(stsLiteral.getText());
 
+        writeTrailingComments(stsLiteral);
         return null;
     }
 
@@ -1946,28 +2350,43 @@ public class StaticTSWriter extends StaticTSParserBaseVisitor<Void> {
     @Override
     public Void visitDeferStatement(DeferStatementContext stsDeferStatement) {
         doNeededIndent();
+        writeLeadingComments(stsDeferStatement);
 
         sb.append(stsDeferStatement.Defer().getText()).append(' ');
         stsDeferStatement.statement().accept(this);
 
+        writeTrailingComments(stsDeferStatement);
         return null;
     }
 
     // Try singleExpression # TryExpression
     @Override
     public Void visitTryExpression(TryExpressionContext stsTryExpression) {
+        writeLeadingComments(stsTryExpression);
+
         sb.append(stsTryExpression.Try()).append(' ');
         stsTryExpression.singleExpression().accept(this);
 
+        writeTrailingComments(stsTryExpression);
         return null;
     }
 
-    private void visitComment(ParserRuleContext parentNode, int childIndex) {
-        if (parentNode.getChildCount() > childIndex) {
-            ParseTree childNode = parentNode.getChild(childIndex);
-            if (childNode instanceof TerminalNode) {
-                visitTerminal((TerminalNode)childNode);
-            }
-        }
+    // This is to emit comments that we attached to nodes for
+    // which we don't have explicit visit function above.
+    @Override
+    public Void visitChildren(RuleNode node) {
+        StaticTSContextBase stsNode = node instanceof StaticTSContextBase ?
+                                      (StaticTSContextBase)node : null;
+        writeLeadingComments(stsNode);
+
+        super.visitChildren(node);
+
+        writeTrailingComments(stsNode);
+        return null;
+    }
+    public void visitDummyNode(StaticTSContextBase stsContextBase) {
+        // Just dump comments on this node.
+        writeLeadingComments(stsContextBase);
+        writeTrailingComments(stsContextBase);
     }
 }
diff --git a/migrator/src/com/ohos/migrator/util/FileUtils.java b/migrator/src/com/ohos/migrator/util/FileUtils.java
index 1da9953107a398bd6db38521ec8cc2f7b815f6c4..5a02aef51191b40e45e3b960b9e8b77ebda1e7f5 100644
--- a/migrator/src/com/ohos/migrator/util/FileUtils.java
+++ b/migrator/src/com/ohos/migrator/util/FileUtils.java
@@ -45,14 +45,11 @@ public class FileUtils {
        String[] resultText = readFile(resultFile);
        String[] expectedText = readFile(expectedFile);
 
-       // Temporary changes to offset for leading copyright & license comment.
-       // TODO: Remove after comment translation is implemented!!!
-       if (expectedText.length - resultText.length != 14)
-       //if (resultText.length != expectedText.length)
+       if (resultText.length != expectedText.length)
            return false;
 
        for (int i = 0; i < resultText.length; ++i) {
-           if (!resultText[i].equals(expectedText[i+14])) // TODO: Remove offset here when comments are translated!!!
+           if (!resultText[i].equals(expectedText[i]))
                return false;
        }
 
diff --git a/migrator/test/java/class_instance_initializer.java.sts b/migrator/test/java/class_instance_initializer.java.sts
index c77a40cc6db0538bf23e3e8911a7cff1f4ab7b23..1d66c6cf911c61d903335c208d612e50fb1bc848 100644
--- a/migrator/test/java/class_instance_initializer.java.sts
+++ b/migrator/test/java/class_instance_initializer.java.sts
@@ -20,11 +20,13 @@ open class A  {
     public constructor() {
         a = 2;
         b = 4;
+// Inits are inserted here.
         a = 10;
         b = 20;
     }
 
     public constructor(p : int) {
+// Inits are NOT inserted here.
         this();
         a = 30;
         b = 40;
@@ -33,6 +35,7 @@ open class A  {
     public constructor(s : String) {
         a = 2;
         b = 4;
+// Inits are inserted here.
         a = 50;
         b = 60;
     }
@@ -45,11 +48,13 @@ open class B extends A  {
     public constructor() {
         c += 22;
         d -= 44;
+// Inits are inserted here.
         c = 100;
         d = 200;
     }
 
     public constructor(p : int) {
+// Inits are NOT inserted here.
         this();
         c = 300;
         d = 400;
@@ -59,12 +64,14 @@ open class B extends A  {
         super(0);
         c += 22;
         d -= 44;
+// Inits are inserted here (after super() call).
         c = 500;
         d = 600;
     }
 
 }
 
+// instance initializer without ctors
 open class C  {
     foo : String ;
 
diff --git a/migrator/test/java/enum_with_class_behavior.java.sts b/migrator/test/java/enum_with_class_behavior.java.sts
index 010862bf2cf11b59f2001bf0fb9d8ad8dad38847..367f7e1dedb45ed2f165e2c2f62873eb8846d1f1 100644
--- a/migrator/test/java/enum_with_class_behavior.java.sts
+++ b/migrator/test/java/enum_with_class_behavior.java.sts
@@ -14,6 +14,8 @@
  */
 package com.ohos.migrator.test.java;
 
+// Enum implements an interface.
+// Constants with class body (anonymous class declaration).
 interface IOperation {
     apply(a : int, b : int): int ;
 }
@@ -40,6 +42,9 @@ open class ArithmeticOperation extends Enum<ArithmeticOperation> implements IOpe
                                                          }
                                                      };
 
+    // tests enum instance initializer translation
+    // super(name, ordinal) call should be inserted
+    // into resulting ctor!
     private foo : String ;
 
     public static values(): ArithmeticOperation[] {
@@ -57,6 +62,8 @@ open class ArithmeticOperation extends Enum<ArithmeticOperation> implements IOpe
         foo = "bar";
     }    
 }
+// Enum declaration with type members (ctor, methods, etc).
+// Constants are initialized through constructor.
 class Planet extends Enum<Planet>  {
     public static const MERCURY : Planet = new Planet("MERCURY", 0, 3.303e+23, 2.4397e6);
     public static const VENUS : Planet = new Planet("VENUS", 1, 4.869e+24, 6.0518e6);
@@ -86,8 +93,8 @@ class Planet extends Enum<Planet>  {
         }
     }
 
-    private mass : double ;
-    private radius : double ;
+    private mass : double ; // in kilograms
+    private radius : double ; // in meters
     private type : PlanetType ;
 
     constructor(name : String, ordinal : int, mass : double, radius : double, type : PlanetType) {
@@ -98,9 +105,12 @@ class Planet extends Enum<Planet>  {
     }
 
     constructor(name : String, ordinal : int, mass : double, radius : double) {
+        // No super(name, ordinal) call in translation here!
         this(name, ordinal, mass, radius, PlanetType.ROCK);
     }
 
+    // Checks addition of name and ordinal parameters
+    // to explcitly-defined parameter-less enum ctor.
     private constructor(name : String, ordinal : int) {
         super(name, ordinal);
         mass = 0.;
@@ -108,10 +118,13 @@ class Planet extends Enum<Planet>  {
         type = PlanetType.ROCK;
     }
 
+    // Checks addition of name and ordinal arguments
+    // to explicit parameter-less ctor call
     private constructor(name : String, ordinal : int, mass : double) {
         this(name, ordinal);
     }
 
+    // universal gravitational constant  (m3 kg-1 s-2)
     public static const G : double = 6.67300E-11;
 
     open surfaceGravity(): double {
diff --git a/migrator/test/java/generic_class_1.java.sts b/migrator/test/java/generic_class_1.java.sts
index 192ed6b394cc627b6416df56cf5d0930f78d0f44..f398b2cf87387d5e0e3256a9aa090f117f14d794 100644
--- a/migrator/test/java/generic_class_1.java.sts
+++ b/migrator/test/java/generic_class_1.java.sts
@@ -14,6 +14,7 @@
  */
 package com.ohos.migrator.test.java;
 
+// Java specification Example 8.1.2-1. Mutually Recursive Type Variable Bounds:
 interface ConvertibleTo<T> {
     convert(): T ;
 }
diff --git a/migrator/test/java/generic_class_2.java.sts b/migrator/test/java/generic_class_2.java.sts
index 085637ec74cc9dfe1f9d514fdbab935c851f552a..b3b7db21d2211323257444629287da8f946fdfb9 100644
--- a/migrator/test/java/generic_class_2.java.sts
+++ b/migrator/test/java/generic_class_2.java.sts
@@ -14,6 +14,7 @@
  */ 
 package com.ohos.migrator.test.java;
 
+// Java specification Example 8.1.2-2. Nested Generic Classes
 open class Seq<T> {
     head : T ;
     tail : Seq<T> ;
diff --git a/migrator/test/java/generic_interface_1.java b/migrator/test/java/generic_interface_1.java
index 3f8d042da91ce806640ba288a25ebdf7da57fe85..9ad2235161f472e710fc6b69e0eac4ffc1b75d00 100644
--- a/migrator/test/java/generic_interface_1.java
+++ b/migrator/test/java/generic_interface_1.java
@@ -17,10 +17,10 @@ package com.ohos.migrator.test.java;
 
 // Java specification Example 9.8-3. Generic Functional Interfaces
 
-//interface I { Object m(Class c); }
+interface I { Object m(Class c); }
 
 interface J<S> { S m(Class<?> c); }
 
 interface K<T> { T m(Class<?> c); }
 
-//interface Functional<S, T> extends I, J<S>, K<T> {}
\ No newline at end of file
+interface Functional<S, T> extends I, J<S>, K<T> {}
diff --git a/migrator/test/java/generic_interface_1.java.sts b/migrator/test/java/generic_interface_1.java.sts
index f0ebc7f76ffe622e24ea5fe4be7984741d582f88..6888eb8f3f5e5ec246a07208ed3ca796af48815a 100644
--- a/migrator/test/java/generic_interface_1.java.sts
+++ b/migrator/test/java/generic_interface_1.java.sts
@@ -12,9 +12,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package com.ohos.migrator.test.java;
 
+// Java specification Example 9.8-3. Generic Functional Interfaces
+interface I {
+    m(c : Class<>): Object ;
+}
+
 interface J<S> {
     m(c : Class<out>): S ;
 }
@@ -23,3 +27,6 @@ interface K<T> {
     m(c : Class<out>): T ;
 }
 
+interface Functional<S, T> extends I, J<S>, K<T> {
+}
+
diff --git a/migrator/test/java/generic_interface_2.java.sts b/migrator/test/java/generic_interface_2.java.sts
index 7c24c7520f5616838167a522e29620d9e7d5ed82..39cf74cd9be8f1e37e8b59f4c92c1c727c57dbcd 100644
--- a/migrator/test/java/generic_interface_2.java.sts
+++ b/migrator/test/java/generic_interface_2.java.sts
@@ -14,6 +14,7 @@
  */
 package com.ohos.migrator.test.java;
 
+// Java specification Example 9.9-2. Generic Function Types
 interface G1 {
     m<E extends Exception>(): Object  throws ;
 }
diff --git a/migrator/test/java/inferred_types.java.sts b/migrator/test/java/inferred_types.java.sts
index 6cbc8e19cf272da142a409c925a073b3c8b555a9..c1e33975fd297ae7c659f3199b37d42c5063a49b 100644
--- a/migrator/test/java/inferred_types.java.sts
+++ b/migrator/test/java/inferred_types.java.sts
@@ -12,11 +12,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package com.ohos.migrator.tests.java;
 
 import java.util.List;
 open class Main  {
+// Java language allows to omit return/parameter types for lambda expression.
+// These types are then inferred by the compiler.
+// This test covers all kinds of types that can be inferred by compiler
     open class C  {
     }
 
@@ -38,54 +40,55 @@ open class Main  {
 
     interface IPrimitiveTypes {
         M(i : int, b : boolean, c : char): void ;
-    }
+    } // Void, primitive types
 
     interface IClassTypes {
         M(c : C, s : String, e : E): IPrimitiveTypes ;
-    }
+    } // Class, Interface, Enum
 
     interface IArrays {
         M(sArray : String[], iArray : IPrimitiveTypes[][], eArray : E[][]): int[] ;
-    }
+    } // Arrays
 
     interface IParametrizedTypes {
         M(list : List<Integer>, listOfArrays : List<IPrimitiveTypes[]>, listOfLists : List<List<String>>[]): List<> ;
-    }
+    } // Parametrized type, Raw type
 
     interface IWildcards {
         M(listExtends : List<out Number>, listSuper : List<in Integer>): List<out> ;
-    }
+    } // Wildcards
 
     interface IGeneric<T> {
         M(list : List<T>): T ;
-    }
+    } // Generic interface (parametrized types, type variables, wildcards, etc.)
 
     static open class OuterClass<T> {
         open class InnerClass  {
             open M(t : T): void {
-                let l : IGeneric<T> = (list : java.util.List<T>): T  =>list.get(0);
+                let l : IGeneric<T> = (list : java.util.List<T>): T  =>list.get(0); // Generic functional interface parametrized with type variable
             }
         }
 
     }
 
     interface IInnerOuter {
-        M(inner : OuterClass<List<String>>.InnerClass): int ;
+        M(inner : OuterClass<List<String>>.InnerClass): int ; // Nested type (with parametrized type)
     }
 
     open Test(): void {
         let l1 : IPrimitiveTypes = (i : int, b : boolean, c : char): void  => {
         }
-;
-        let l2 : IClassTypes = (c : com.ohos.migrator.tests.java.Main.C, s : java.lang.String, e : com.ohos.migrator.tests.java.Main.E): com.ohos.migrator.tests.java.Main.IPrimitiveTypes  =>l1;
-        let l3 : IArrays = (sArray : java.lang.String[], iArray : com.ohos.migrator.tests.java.Main.IPrimitiveTypes[][], eArray : com.ohos.migrator.tests.java.Main.E[][]): int[]  =>new int[5];
-        let l4 : IParametrizedTypes = (list : java.util.List<java.lang.Integer>, listOfArrays : java.util.List<com.ohos.migrator.tests.java.Main.IPrimitiveTypes[]>, ListOfLists : java.util.List<java.util.List<java.lang.String>>[]): java.util.List<>  =>list;
-        let l5 : IWildcards = (listExtends : java.util.List<out java.lang.Number>, listSuper : java.util.List<in java.lang.Integer>): java.util.List<out>  =>listExtends;
-        let l6 : IGeneric<Number> = (list : java.util.List<java.lang.Number>): java.lang.Number  =>list.get(0);
-        let l7 : IGeneric<out> = (list : java.util.List<java.lang.Object>): java.lang.Object  =>list.get(0);
-        let l8 : IGeneric<out Number> = (list : java.util.List<java.lang.Number>): java.lang.Number  =>list.get(0);
-        let l9 : IGeneric<in Number> = (list : java.util.List<java.lang.Number>): java.lang.Number  =>list.get(0);
-        let l10 : IInnerOuter = (inner : com.ohos.migrator.tests.java.Main.OuterClass<java.util.List<java.lang.String>>.InnerClass): int  =>0;
+; // Void, primitive types
+        let l2 : IClassTypes = (c : com.ohos.migrator.tests.java.Main.C, s : java.lang.String, e : com.ohos.migrator.tests.java.Main.E): com.ohos.migrator.tests.java.Main.IPrimitiveTypes  =>l1; // Class, Interface, Enum
+        let l3 : IArrays = (sArray : java.lang.String[], iArray : com.ohos.migrator.tests.java.Main.IPrimitiveTypes[][], eArray : com.ohos.migrator.tests.java.Main.E[][]): int[]  =>new int[5]; // Arrays
+        let l4 : IParametrizedTypes = (list : java.util.List<java.lang.Integer>, listOfArrays : java.util.List<com.ohos.migrator.tests.java.Main.IPrimitiveTypes[]>, ListOfLists : java.util.List<java.util.List<java.lang.String>>[]): java.util.List<>  =>list; // Parametrized type, Raw type
+        let l5 : IWildcards = (listExtends : java.util.List<out java.lang.Number>, listSuper : java.util.List<in java.lang.Integer>): java.util.List<out>  =>listExtends; // Wildcards
+// Generic functional interface
+        let l6 : IGeneric<Number> = (list : java.util.List<java.lang.Number>): java.lang.Number  =>list.get(0); // parametrized with explicit type
+        let l7 : IGeneric<out> = (list : java.util.List<java.lang.Object>): java.lang.Object  =>list.get(0); // parametrized with wildcard
+        let l8 : IGeneric<out Number> = (list : java.util.List<java.lang.Number>): java.lang.Number  =>list.get(0); // parametrized with wildcard with bound
+        let l9 : IGeneric<in Number> = (list : java.util.List<java.lang.Number>): java.lang.Number  =>list.get(0); // parametrized with wildcard with bound
+        let l10 : IInnerOuter = (inner : com.ohos.migrator.tests.java.Main.OuterClass<java.util.List<java.lang.String>>.InnerClass): int  =>0; // Nested type (with parametrized type)
     }
 }
 
diff --git a/migrator/test/java/literals.java.sts b/migrator/test/java/literals.java.sts
index 9d7f26e56062e5ebf656cfb69b03a9dc9200b997..ac56696e01c0e99e092c32a434486c4c1d287015 100755
--- a/migrator/test/java/literals.java.sts
+++ b/migrator/test/java/literals.java.sts
@@ -17,6 +17,7 @@ package com.ohos.migrator.test.java;
 
 open class literals  {
     open test(): void {
+// integer literals
         let b : byte = 0;
         let b2 : byte = 1_0_2;
         let s : short = 0x1;
@@ -25,6 +26,7 @@ open class literals  {
         let i2 : int = 0o3_4_56;
         let l : long = 0b11;
         let l2 : long = 0B1_01_11;
+// floating-point literals
         let f : float = 4;
         let f2 : float = 1_2.23_45e+6;
         let f3 : float = 3.402_823_5e1_7;
@@ -33,14 +35,17 @@ open class literals  {
         let d3 : double = 0.123876;
         let pi : double = 3.1416;
         let G : double = 6.6_73_00E-11;
+// char and string literals
         let c : char = '6';
         let c2 : char = '\t';
         let c3 : char = '\'';
         let str : String = "7";
         let str2 : String = "Who needs \"dots\" over \"eyes\"? ;)\r\n";
+// null and boolean literals
         let nl : literals = null;
         let tl : boolean = true;
         let fl : boolean = false;
+// class literals
         let cl : Class<literals> = literals.class;
         let ll : Class<out> = long.class;
         let sal : Class<String[]> = String[].class;
diff --git a/migrator/test/java/method_empty.java.sts b/migrator/test/java/method_empty.java.sts
index f7383f767fbcff800c0eb3a4fed5d92ca6f97dd0..3f026008f0d85d71c0b7d15870bf4212779bba65 100644
--- a/migrator/test/java/method_empty.java.sts
+++ b/migrator/test/java/method_empty.java.sts
@@ -17,12 +17,9 @@ package com.ohos.migrator.tests.java;
 open class A  {
     public open foo(): void {
     }
-
     private foo(i : int): void {
     }
-
     static foo(d : double): void {
     }
-
-}
+} //public override void foo(float f) {  }
 
diff --git a/migrator/test/java/method_invocation.java b/migrator/test/java/method_invocation.java
index 1c8887cb5902a8a3f613382f502f47f5a6b21f34..fde6d7cee61be7e537de0c3827dc488d77ec45c5 100644
--- a/migrator/test/java/method_invocation.java
+++ b/migrator/test/java/method_invocation.java
@@ -46,7 +46,7 @@ class SubClass3 implements SuperInterface {
 
     Runnable tweak = new Runnable() {
         public void run() {
-            //SubClass3.SuperInterface.super.foo(); // Illegal
+            SubClass3.SuperInterface.super.foo(); // Illegal
         }
     };
 }
@@ -61,7 +61,7 @@ class Test extends Doubler {
 
     public static void main(String[] args) {
         System.out.println(two(3));
-        //System.out.println(Doubler.two(3)); // Compile-time error
+        System.out.println(Doubler.two(3)); // Compile-time error
     }
 }
 
@@ -76,7 +76,7 @@ class Test2 {
         ColoredPoint cp = new ColoredPoint();
         byte color = 37;
         cp.setColor(color);
-        //cp.setColor(37); // Compile-time error
+        cp.setColor(37); // Compile-time error
     }
 }
 
@@ -91,6 +91,6 @@ class Test3 {
     }
     public static void main(String[] args) {
         ColoredPoint2 cp = new ColoredPoint2();
-        //test(cp, cp); // Compile-time error
+        test(cp, cp); // Compile-time error
     }
 }
diff --git a/migrator/test/java/method_invocation.java.sts b/migrator/test/java/method_invocation.java.sts
old mode 100644
new mode 100755
index 2dabc2f98c1adf2bfb699c9287dfd7ddb00206aa..a2b0bacd52016acef7ecbc50619b2185868496bb
--- a/migrator/test/java/method_invocation.java.sts
+++ b/migrator/test/java/method_invocation.java.sts
@@ -26,7 +26,7 @@ open class SubClass1 extends SuperClass  {
     }
     tweak : Runnable = new Runnable() {
         public override run(): void {
-            SubClass1.super.foo();
+            SubClass1.super.foo(); // Gets the 'println' behavior
         }
     };
 }
@@ -42,7 +42,7 @@ open class SubClass2 implements SuperInterface  {
         panic new UnsupportedOperationException();
     }
     open tweak(): void {
-        SuperInterface.super.foo();
+        SuperInterface.super.foo(); // Gets the 'println' behavior
     }
 }
 
@@ -52,6 +52,7 @@ open class SubClass3 implements SuperInterface  {
     }
     tweak : Runnable = new Runnable() {
         public override run(): void {
+            SubClass3.SuperInterface.super.foo(); // Illegal
         }
     };
 }
@@ -71,6 +72,7 @@ open class Test extends Doubler  {
     }
     public static main(args : String[]): void {
         System.out.println(two(3));
+        System.out.println(Doubler.two(3)); // Compile-time error
     }
 }
 
@@ -88,6 +90,7 @@ open class Test2  {
         let cp : ColoredPoint = new ColoredPoint();
         let color : byte = 37;
         cp.setColor(color);
+        cp.setColor(37); // Compile-time error
     }
 }
 
@@ -109,6 +112,7 @@ open class Test3  {
     }
     public static main(args : String[]): void {
         let cp : ColoredPoint2 = new ColoredPoint2();
+        test(cp, cp); // Compile-time error
     }
 }
 
diff --git a/migrator/test/java/method_references.java b/migrator/test/java/method_references.java
index 15b37546f763a6a4825ceeee5c39a7300c7b571c..d28ff7d8b1e59a5a18d3f4d29cb53682e0f22b62 100644
--- a/migrator/test/java/method_references.java
+++ b/migrator/test/java/method_references.java
@@ -172,14 +172,14 @@ class MethodReferencesExamples {
 
         IVarargs i1m1 = obj::m1;
         IVarargs2 i2m1 = obj::m1;
-        //IVarargs3 i3m1 = obj::m1; // Illegal
+        IVarargs3 i3m1 = obj::m1; // Illegal
 
         IVarargs i1m2 = obj::m2;
         IVarargs2 i2m2 = obj::m2;
-        //IVarargs3 i3m2 = obj::m2; // Illegal
+        IVarargs3 i3m2 = obj::m2; // Illegal
 
         IVarargs i1m3 = obj::m3;
-        //IVarargs2 i2m3 = obj::m3; // Illegal
+        IVarargs2 i2m3 = obj::m3;
         IVarargs3 i3m3 = obj::m3;
     }
 
diff --git a/migrator/test/java/method_references.java.sts b/migrator/test/java/method_references.java.sts
index 8c031b37cfed2804cb5e1c0f59a74264f9084873..096e71bafebfab33b6678c22d25748ec5dfb1702 100644
--- a/migrator/test/java/method_references.java.sts
+++ b/migrator/test/java/method_references.java.sts
@@ -11,8 +11,7 @@
 * 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.
-*/ 
-
+*/
 package com.ohos.migrator.tests.java;
 
 open class MethodReferencesExamples  {
@@ -85,21 +84,29 @@ open class MethodReferencesExamples  {
 
     public static classMethodReferences(): void {
         let myApp : MethodReferencesExamples = new MethodReferencesExamples();
+// Reference to static method | ContainingClass::staticMethodName
         System.out.println(MethodReferencesExamples.mergeThings("Hello ", "World!", (__migrator_lambda_param_1 : java.lang.String, __migrator_lambda_param_2 : java.lang.String): java.lang.String  =>MethodReferencesExamples.appendStrings(__migrator_lambda_param_1, __migrator_lambda_param_2)));
+// Reference to an instance method of a particular object | containingObject::instanceMethodName
         System.out.println(MethodReferencesExamples.mergeThings("Hello ", "World!", (__migrator_lambda_param_1 : java.lang.String, __migrator_lambda_param_2 : java.lang.String): java.lang.String  =>myApp.appendStrings2(__migrator_lambda_param_1, __migrator_lambda_param_2)));
+// Reference to an instance method of an arbitrary object of a particular type | ContainingType::methodName
         System.out.println(MethodReferencesExamples.mergeThings("Hello ", "World!", (__migrator_lambda_param_1 : java.lang.String, __migrator_lambda_param_2 : java.lang.String): java.lang.String  =>__migrator_lambda_param_1.concat(__migrator_lambda_param_2)));
+// Reference to a constructor | ClassName::new
         let person : Person = myApp.factory((): com.ohos.migrator.tests.java.MethodReferencesExamples.Person  =>new Person());
         let person2 : Person = myApp.factory((__migrator_lambda_param_1 : int): com.ohos.migrator.tests.java.MethodReferencesExamples.Person  =>new Person(__migrator_lambda_param_1), 25);
         let person3 : Person = myApp.factory((__migrator_lambda_param_1 : int, __migrator_lambda_param_2 : java.lang.String): com.ohos.migrator.tests.java.MethodReferencesExamples.Person  =>new Person(__migrator_lambda_param_1, __migrator_lambda_param_2), 40, "Peter");
+// Reference with qualified type name
         let cons1 : Consumer<A.B> = (__migrator_lambda_param_1 : com.ohos.migrator.tests.java.MethodReferencesExamples.A.B): void  =>__migrator_lambda_param_1.foo();
         let cons2 : Consumer<String> = (__migrator_lambda_param_1 : java.lang.String): void  =>A.B.bar(__migrator_lambda_param_1);
+// Reference with parametrized type name
         let generic : BiConsumer<Generic<>, Integer> = (__migrator_lambda_param_1 : com.ohos.migrator.tests.java.MethodReferencesExamples.Generic<java.lang.Integer>, __migrator_lambda_param_2 : java.lang.Integer): void  =>__migrator_lambda_param_1.bar(__migrator_lambda_param_2);
+// Reference with primary expressions
         let getLength : Function0<Integer> = (): int  =>"sleeping".length();
         let length : int = getLength.apply();
         let persons : Person[] = new Person[5];
         let sleep : Consumer<Integer> = (__migrator_lambda_param_1 : int): void  =>persons[2].sleep(__migrator_lambda_param_1);
         sleep.apply(length);
     }
+// Arrays
     interface ArrayFactory<T> {
         createArray(size : int): T[] ;
     }
@@ -131,6 +138,7 @@ open class MethodReferencesExamples  {
         let newArray3 : Double[][][] = arrayFactory3.createArray(15);
         java.util.Arrays.stream(new Object[5]).toArray((__migrator_lambda_param_1 : int): String[]  =>new String[__migrator_lambda_param_1]);
     }
+// Varargs
     interface IVarargs {
         m(s : String, i : int[]): int ;
     }
@@ -159,11 +167,15 @@ open class MethodReferencesExamples  {
         let obj : VarArgs = new VarArgs();
         let i1m1 : IVarargs = (__migrator_lambda_param_1 : java.lang.String, __migrator_lambda_param_2 : int[]): int  =>obj.m1(__migrator_lambda_param_1, __migrator_lambda_param_2);
         let i2m1 : IVarargs2 = (__migrator_lambda_param_1 : java.lang.String, __migrator_lambda_param_2 : int[]): int  =>obj.m1(__migrator_lambda_param_1, __migrator_lambda_param_2);
+        let i3m1 : IVarargs3 = __untranslated_expression( /* obj::m1 */); // Illegal
         let i1m2 : IVarargs = (__migrator_lambda_param_1 : java.lang.String, __migrator_lambda_param_2 : int[]): int  =>obj.m2(__migrator_lambda_param_1, __migrator_lambda_param_2);
         let i2m2 : IVarargs2 = (__migrator_lambda_param_1 : java.lang.String, __migrator_lambda_param_2 : int[]): int  =>obj.m2(__migrator_lambda_param_1, __migrator_lambda_param_2);
+        let i3m2 : IVarargs3 = __untranslated_expression( /* obj::m2 */); // Illegal
         let i1m3 : IVarargs = (__migrator_lambda_param_1 : java.lang.String, __migrator_lambda_param_2 : int[][]): int  =>obj.m3(__migrator_lambda_param_1, __migrator_lambda_param_2);
+        let i2m3 : IVarargs2 = (__migrator_lambda_param_1 : java.lang.String, __migrator_lambda_param_2 : int[][]): int  =>obj.m3(__migrator_lambda_param_1, __migrator_lambda_param_2);
         let i3m3 : IVarargs3 = (__migrator_lambda_param_1 : java.lang.String, __migrator_lambda_param_2 : int[][]): int  =>obj.m3(__migrator_lambda_param_1, __migrator_lambda_param_2);
     }
+// Inner/outer classes
     interface FooMethod {
         foo(x : int): int ;
     }
@@ -185,6 +197,7 @@ open class MethodReferencesExamples  {
         public open bar(): void {
             let thisFoo : FooMethod = (__migrator_lambda_param_1 : int): int  =>this.foo(__migrator_lambda_param_1);
             let superFoo : FooMethod = (__migrator_lambda_param_1 : int): int  =>super.foo(__migrator_lambda_param_1);
+// Local inner class
             open class LocalInner  {
                 open foo(): void {
                     let outerThisFoo : FooMethod = (__migrator_lambda_param_1 : int): int  =>Outer.this.foo(__migrator_lambda_param_1);
@@ -193,22 +206,24 @@ open class MethodReferencesExamples  {
             }
 
         }
+// Inner class
         open class Inner  {
             open foo(): void {
                 let outerThisFoo : FooMethod = (__migrator_lambda_param_1 : int): int  =>Outer.this.foo(__migrator_lambda_param_1);
                 let outerSuperFoo : FooMethod = (__migrator_lambda_param_1 : int): int  =>Outer.super.foo(__migrator_lambda_param_1);
             }
             open innerContext(): InnerFactory {
-                return (): com.ohos.migrator.tests.java.MethodReferencesExamples.Outer.Inner  =>new Inner();
+                return (): com.ohos.migrator.tests.java.MethodReferencesExamples.Outer.Inner  =>new Inner(); // Creation reference from Inner context
             }
         }
 
         public open outerContext(): void {
-            let factory : InnerFactory = (): com.ohos.migrator.tests.java.MethodReferencesExamples.Outer.Inner  =>new Inner();
+            let factory : InnerFactory = (): com.ohos.migrator.tests.java.MethodReferencesExamples.Outer.Inner  =>new Inner(); // Creation reference from Outer context
             let inner : Inner = factory.create();
         }
     }
 
+// Exceptions and error handling
     interface TryFunction0<T> {
         apply(): T  throws ;
     }
@@ -241,4 +256,4 @@ open class MethodReferencesExamples  {
 
     }
 }
- 
+
diff --git a/migrator/test/java/named_types.java b/migrator/test/java/named_types.java
index c38984a81d1591cafa2b9b90243fcfbdd9f87179..d934fe2643c3e4ba3c907558d168b0536fa747a3 100644
--- a/migrator/test/java/named_types.java
+++ b/migrator/test/java/named_types.java
@@ -36,7 +36,7 @@ class auxilliary {
         return null;
     }
 
-    // Tests qualified types in QualifierType AST form
+    // Tests qualified types in QualifiedType AST form
     public named_types.inner<String>.innertoo.inneragain bar() {
         return null;
     }
diff --git a/migrator/test/java/named_types.java.sts b/migrator/test/java/named_types.java.sts
index f28a77dc911e74fecf61729ca4a706c5d9da8cac..6557fd482306930014503ed1ab339f684102ea04 100644
--- a/migrator/test/java/named_types.java.sts
+++ b/migrator/test/java/named_types.java.sts
@@ -17,6 +17,7 @@ package com.ohos.migrator.test.java;
 import java.util.List;
 import java.lang.annotation.*;
 open class named_types  {
+// Tests qualified types in SimpleType AST form
     text : java.lang.String ;
     public static open class inner<T> {
         public open class innertoo  {
@@ -29,18 +30,22 @@ open class named_types  {
 }
 
 open class auxilliary  {
+// Tests qualified types in NameQualifiedType AST form
     public open foo(): named_types.inner<> {
         return null;
     }
 
+// Tests qualified types in QualifiedType AST form
     public open bar(): named_types.inner<String>.innertoo.inneragain {
         return null;
     }
 
+// Test qualified types in ParametrizedType AST form
     public open foobar(arg : named_types.inner<out>): named_types.inner<String> {
         return null;
     }
 
+
     public open barfoo(arg : named_types.inner<in String>): named_types.inner<out String> {
         return null;
     }
diff --git a/migrator/test/java/npe_in_method_reference.java.sts b/migrator/test/java/npe_in_method_reference.java.sts
index 9f2b9afeded820cd027cbf34ca1699a9251e91e0..53e872f458eb57dfb846a267932d319b799ad07f 100644
--- a/migrator/test/java/npe_in_method_reference.java.sts
+++ b/migrator/test/java/npe_in_method_reference.java.sts
@@ -24,6 +24,6 @@ open class npe_in_method_reference<T> {
     }
 
     open test(): void {
-        let a : Action = __untranslated_expression(/* npe_in_method_reference<String>::foo */);
+        let a : Action = __untranslated_expression( /* npe_in_method_reference<String>::foo */);
     }
 }
diff --git a/migrator/test/java/switch_statement.java.sts b/migrator/test/java/switch_statement.java.sts
index 36e61cd3b2975a6303b46c00a6fc5a33f331e637..c76cfc3d937702286431aca1325d9c5f3fc1368c 100644
--- a/migrator/test/java/switch_statement.java.sts
+++ b/migrator/test/java/switch_statement.java.sts
@@ -11,8 +11,7 @@
  * 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.
- */ 
-
+ */
 package com.ohos.migrator.test.java;
 
 export open class switch_statement  {
@@ -29,9 +28,11 @@ export open class switch_statement  {
     }
     public static CaseClausesVariations(): void {
         let a : int = 0;
+// empty switch
         switch (1) {
         }
 
+// no default clause
         switch (2) {
             case 1:
                 a = 21;
@@ -41,12 +42,14 @@ export open class switch_statement  {
                 break;
         }
 
+// only default case
         switch (3) {
             default:
                 a = 31;
                 break;
         }
 
+// case clause followed by default
         switch (4) {
             case 1:
                 a = 41;
@@ -58,6 +61,7 @@ export open class switch_statement  {
                 break;
         }
 
+// case clause following default clause
         switch (5) {
             default:
                 a = 51;
@@ -70,6 +74,7 @@ export open class switch_statement  {
                 break;
         }
 
+// case clauses before and after default clause
         switch (6) {
             case 1:
                 a = 61;
@@ -82,6 +87,7 @@ export open class switch_statement  {
                 break;
         }
 
+// Fall-through
         switch (7) {
             case 1:
             case 2:
@@ -92,6 +98,7 @@ export open class switch_statement  {
                 break;
         }
 
+// Fall-through
         switch (8) {
             case 1:
             default:
@@ -99,6 +106,7 @@ export open class switch_statement  {
                 break;
         }
 
+// Fall-through
         switch (9) {
             case 1:
                 System.out.println("In case 1: Falling through to default case");
@@ -113,9 +121,10 @@ export open class switch_statement  {
     }
     public static SwitchWithLocalDeclarations(): void {
         let i : int = 10;
+// Local variable is referenced across several case clauses.
         {
-            let w : int ;
-            let e : int ;
+            let w : int ; // This declaration is moved in front of switch. Initialization is turned into assignment.
+            let e : int ; // This declaration is moved in front of switch. No initialization.
             switch (i) {
                 case 0:
                     {
@@ -131,6 +140,7 @@ export open class switch_statement  {
             }
 
         }
+// Multiple variables in single variable declaration list.
         {
             let q : int ;
             let r : int ;
@@ -138,9 +148,9 @@ export open class switch_statement  {
                 case 0:
                     {
                         q = 5;
-                        let w : int ;
+                        let w : int ; // 'q' and 'r' are moved in front of switch.
                         let e : int = 10;
-                        let z : int = 20;
+                        let z : int = 20; // Both 'z' and 'x' declarations are left in this block.
                         let x : int ;
                         System.out.println(q + e + z);
                         break;
@@ -153,12 +163,13 @@ export open class switch_statement  {
             }
 
         }
+// Block variable and hiding.
         {
             let localVar : int ;
             switch (i) {
                 case 1:
                     {
-                        let localVar : String = "some value";
+                        let localVar : String = "some value"; // 'String localVar' will hide the 'int localVar' in current block scope.
                     }
                     break;
                 case 2:
@@ -170,6 +181,8 @@ export open class switch_statement  {
             }
 
         }
+// Local variable is initialized with expression that can cause side-effects.
+// The order of evaluation of variable initializers must be preserved.
         {
             let q : int ;
             let e : int ;
@@ -188,6 +201,8 @@ export open class switch_statement  {
             }
 
         }
+// Variable 'k' is referenced from nested switch, though, it's still being used
+// only within the case clause it was declared in.
         switch (i) {
             case 1:
                 {
@@ -206,6 +221,7 @@ export open class switch_statement  {
                 break;
         }
 
+// Switch with local class declaration
         switch (i) {
             case 1:
                 {
@@ -223,7 +239,6 @@ export open class switch_statement  {
         }
 
     }
-
     static class Color extends Enum<Color>  {
         public static const Red : Color = new Color("Red", 0);
         public static const Green : Color = new Color("Green", 1);
@@ -240,6 +255,7 @@ export open class switch_statement  {
         private constructor(name : String, ordinal : int) {
             super(name, ordinal);
         }
+
     }
 
     private static SwitchWithEnumValues(): void {
@@ -258,4 +274,4 @@ export open class switch_statement  {
 
     }
 }
- 
+
diff --git a/migrator/test/java/test_enum.java.sts b/migrator/test/java/test_enum.java.sts
index 5f835b0403abe9929731f93eb787a7f4f06e22c5..3b84001549e9caeabc6148c99ef71e872f0c9071 100644
--- a/migrator/test/java/test_enum.java.sts
+++ b/migrator/test/java/test_enum.java.sts
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 package com.ohos.migrator.test.java;
-
+// Empty enum
 export class test_enum extends Enum<test_enum>  {
     public static values(): test_enum[] {
         return [];
@@ -52,6 +52,7 @@ class Planet extends Enum<Planet>  {
         super(name, ordinal);
     }
 }
+// Nested enums with different modifiers
 open class NestedEnums  {
     private static class Colors extends Enum<Colors>  {
         public static const RED : Colors = new Colors("RED", 0);
diff --git a/migrator/test/java/throws_test.java b/migrator/test/java/throws_test.java
index 2529cc4d8f022ff3ac98821ac7ed0be4e8a31b81..baaaf0b455324a5b2f85213d8c76c2f7c499287d 100644
--- a/migrator/test/java/throws_test.java
+++ b/migrator/test/java/throws_test.java
@@ -158,12 +158,9 @@ class Test  {
     }
 
 
-    // snippet untranslateble by Java, uncomment to check there is no NPE! 
-    /***
     interface FunctionalInterface { void foo(); }
     abstract class AbstractException extends Error implements FunctionalInterface {}
 
     final AbstractException notInitialized = (AbstractException)( (FunctionalInterface)( () -> { throw notInitialized; } ) );
-    ***/
 }
 
diff --git a/migrator/test/java/throws_test.java.sts b/migrator/test/java/throws_test.java.sts
index 5bce61a9beec0adde104f0fd26682bc26007273c..d5134b3b639b3c93a5c3a5136ed0be37c0ad8320 100644
--- a/migrator/test/java/throws_test.java.sts
+++ b/migrator/test/java/throws_test.java.sts
@@ -75,10 +75,12 @@ open class SubClass2 extends SubClass1  {
 }
 
 open class Test  {
+// throws
     public static test1(s : String): void  throws {
         let sc1 : SubClass1 = try new SubClass1(s);
         try sc1.foo();
     }
+// throws
     public static test2(s : String): void  throws {
         trap {
             let sc1 : SubClass1 = try new SubClass1(s);
@@ -87,6 +89,7 @@ open class Test  {
         }
 
     }
+// no throws - all excepyions are catched
     public static test3(s : String): void {
         trap {
             let sc1 : SubClass1 = try new SubClass1(s);
@@ -97,6 +100,7 @@ open class Test  {
         }
 
     }
+// no throws - only panic 
     public static test4(s : String): void {
         trap {
             let sc2 : SubClass2 = try new SubClass2(s);
@@ -107,6 +111,7 @@ open class Test  {
         }
 
     }
+// no throws - only panic
     public static test5(s : String): void {
         trap {
             let sc2 : SubClass2 = try new SubClass2(s);
@@ -118,6 +123,7 @@ open class Test  {
         }
 
     }
+// throws
     public static test6(s : String): void  throws {
         trap {
             let sc2 : SubClass2 = try new SubClass2(s);
@@ -127,6 +133,7 @@ open class Test  {
         }
 
     }
+// test for constructor with static initializer
     static open class E1 extends Exception  {
     }
 
@@ -144,6 +151,7 @@ open class Test  {
         m(): void  throws ;
     }
 
+// intersect throws clauses
     abstract static class Tc extends Ta implements Tb  {
         public constructor() {
             trap {
@@ -156,6 +164,7 @@ open class Test  {
 
     }
 
+// STS constructor must have throws clause 
     abstract static class Td extends Ta  {
         public constructor() throws {
             trap {
@@ -168,5 +177,16 @@ open class Test  {
 
     }
 
+    interface FunctionalInterface {
+        foo(): void ;
+    }
+
+    abstract class AbstractException extends Error implements FunctionalInterface  {
+    }
+
+    const notInitialized : AbstractException = (((): void  => {
+        throw notInitialized;
+    }
+) as FunctionalInterface) as AbstractException;
 }
 
diff --git a/migrator/test/java/try_with_resources.java.sts b/migrator/test/java/try_with_resources.java.sts
index 157fc7a516af7611feaf9aacdf674d3045fcf4e2..d296081d124abd35b23e9bafbc6e16d812c3fbd7 100644
--- a/migrator/test/java/try_with_resources.java.sts
+++ b/migrator/test/java/try_with_resources.java.sts
@@ -26,6 +26,7 @@ import java.sql.Statement;
 import java.sql.SQLException;
 import java.util.Scanner;
 open class TryWithResources  {
+// Basic try-with-resources (no catch/finally blocks)
     open readFile(): void  throws {
         let line : String = "";
         let path : String = "";
@@ -93,6 +94,7 @@ open class TryWithResources  {
 
         }
     }
+// with catch block
     open viewTable(con : Connection): void  throws {
         let query : String = "select COF_NAME, SUP_ID, PRICE, SALES, TOTAL from COFFEES";
         trap {
@@ -139,6 +141,7 @@ open class TryWithResources  {
         }
 
     }
+// with finally block
     open readFile2(): void  throws {
         let line : String = "";
         let path : String = "";
@@ -209,6 +212,7 @@ open class TryWithResources  {
 
         }
     }
+// with catch and finally block
     open scanFile(): void {
         trap {
             defer {
@@ -254,6 +258,7 @@ open class TryWithResources  {
         }
 
     }
+// Resource is variable access
     open writeFile(): void {
         trap {
             const scanner : Scanner = try new Scanner(new File("testRead.txt"));
@@ -329,6 +334,7 @@ open class TryWithResources  {
         }
 
     }
+// Resource is field access
     open class Z  {
         public const yz : Y = new Y();
     }
@@ -445,6 +451,19 @@ open class TryWithResources  {
             System.out.println("Closed");
         }
     }
-
+// Currently, "try(this)" case doesn't work properly due to bug
+// in Eclipse JDT library:
+// https://bugs.eclipse.org/bugs/show_bug.cgi?id=577128
+// The bug is present in the version of library that the migrator
+// is currently restricted to use.
+// Uncomment this case, when the library is updated to newer version.
+//
+//        private void bar() {
+//            try (this) {
+//                System.out.println("In Try");
+//            } catch (IOException e) {
+//                System.err.println(e.getMessage());
+//            }
+//        }
 }
 
diff --git a/migrator/test/java/var_declare.java b/migrator/test/java/var_declare.java
index 5e0e8cea1dded3a423f167990a0e3b13ed0f77ab..708f6b86a4855e17bca6efa561c03420f96d7854 100644
--- a/migrator/test/java/var_declare.java
+++ b/migrator/test/java/var_declare.java
@@ -25,8 +25,8 @@ class VarDeclareTest {
 
 	final double e = 2.781828;
 	final float Pi = 3.14f;
-	//final double phi = 0.14e+01;
-	//final double g = 9.81e+00;
-	//final double dd = 4.343234234234234e+00;
+	final double phi = 0.14e+01;
+	final double g = 9.81e+00;
+	final double dd = 4.343234234234234e+00;
     }
 }
diff --git a/migrator/test/java/var_declare.java.sts b/migrator/test/java/var_declare.java.sts
index eec31d5746b27c655b69ce2cc012c4c917f12c7f..3f0a69f1b99bef31ef5c7b55539b8a86eb85c51e 100644
--- a/migrator/test/java/var_declare.java.sts
+++ b/migrator/test/java/var_declare.java.sts
@@ -22,7 +22,9 @@ open class VarDeclareTest  {
         let c : int , d : int = 5;
         const e : double = 2.781828;
         const Pi : float = 3.14;
+        const phi : double = 0.14e+01;
+        const g : double = 9.81e+00;
+        const dd : double = 4.343234234234234e+00;
     }
-
 }