[dart2] Add ports, readme.md, clean up testing (#3740)

* Fix for #3587

Add in changes from #3587 . The desc.xml has been changed to use globstar patterns for test files in latest version of Trash.

* Add readme.md, update desc.xml to do quick sanity check for all but Java port.

* Fix indentation.

* Add Cpp port.

* Add JavaScript port.

* Add Python3 port.

* Fix desc.xml.

* Add Go port.

Renamed "expression" to "expr" to avoid symbol conflict with Go target.

Author: kaby76

dart2/CSharp/Dart2LexerBase.cs

@@ -5,16 +5,16 @@
 
 public abstract class Dart2LexerBase : Lexer
 {
-	protected Dart2LexerBase(ICharStream input)
-		: base(input)
-	{
-	}
+    protected Dart2LexerBase(ICharStream input)
+        : base(input)
+    {
+    }
 
-	public Dart2LexerBase(ICharStream input, TextWriter output, TextWriter errorOutput)
-		: base(input, output, errorOutput) { }
+    public Dart2LexerBase(ICharStream input, TextWriter output, TextWriter errorOutput)
+        : base(input, output, errorOutput) { }
 
-	protected bool CheckNotOpenBrace()
-	{
-		return this.InputStream.LA(1) != '{';
-	}
+    protected bool CheckNotOpenBrace()
+    {
+        return this.InputStream.LA(1) != '{';
+    }
 }

dart2/Cpp/Dart2LexerBase.cpp

@@ -0,0 +1,13 @@
+#include "antlr4-runtime.h"
+#include "Dart2LexerBase.h"
+#include "Dart2Lexer.h"
+
+Dart2LexerBase::Dart2LexerBase(antlr4::CharStream * input) : antlr4::Lexer(input)
+{
+    _input = input;
+}
+
+bool Dart2LexerBase::CheckNotOpenBrace()
+{
+    return this->_input->LA(1) != '{';
+}

dart2/Cpp/Dart2LexerBase.h

@@ -0,0 +1,9 @@
+#pragma once
+#include "antlr4-runtime.h"
+
+class Dart2LexerBase : public antlr4::Lexer
+{
+    public:
+        Dart2LexerBase(antlr4::CharStream * input);
+        bool CheckNotOpenBrace();
+};

dart2/Cpp/transformGrammar.py

@@ -0,0 +1,34 @@
+import sys, os, re, shutil
+from glob import glob
+from pathlib import Path
+
+def main(argv):
+    for file in glob("./*.g4"):
+        fix(file)
+
+def fix(file_path):
+    print("Altering " + file_path)
+    if not os.path.exists(file_path):
+        print(f"Could not find file: {file_path}")
+        sys.exit(1)
+    parts = os.path.split(file_path)
+    file_name = parts[-1]
+    shutil.move(file_path, file_path + ".bak")
+    input_file = open(file_path + ".bak",'r')
+    output_file = open(file_path, 'w')
+    for x in input_file:
+        if '// Insert here @header for C++ lexer.' in x:
+            x = x.replace('// Insert here @header for C++ lexer.', '@header {#include "Dart2LexerBase.h"}')
+        if '// Insert here @header for C++ parser.' in x:
+            x = x.replace('// Insert here @header for C++ parser.', '@header {#include "Dart2ParserBase.h"}')
+        if 'this.' in x:
+            x = x.replace('this.', 'this->')
+        output_file.write(x)
+        output_file.flush()
+
+    print("Writing ...")
+    input_file.close()
+    output_file.close()
+
+if __name__ == '__main__':
+    main(sys.argv)

dart2/Dart/Dart2LexerBase.dart

@@ -3,7 +3,6 @@
 import 'package:antlr4/antlr4.dart';
 
 abstract class Dart2LexerBase extends Lexer {
-  Dart2LexerBase(CharStream input) : super(input);
-
-  bool CheckNotOpenBrace() => inputStream.LA(1) != "{".codeUnitAt(0);
+    Dart2LexerBase(CharStream input) : super(input);
+    bool CheckNotOpenBrace() => inputStream.LA(1) != "{".codeUnitAt(0);
 }

dart2/Dart2Lexer.g4

@@ -27,6 +27,8 @@ lexer grammar Dart2Lexer;
 
 options { superClass=Dart2LexerBase; }
 
+// Insert here @header for C++ lexer.
+
 A: '&';
 AA: '&&';
 AE: '&=';
@@ -158,9 +160,9 @@ MULTI_LINE_COMMENT : '/*' ( MULTI_LINE_COMMENT | . )*? '*/'  -> skip ;
 fragment EXPONENT : ( 'e' | 'E' ) ( '+' | '-' )? DIGIT+ ;
 fragment HEX_DIGIT : 'a' .. 'f' | 'A' .. 'F' | DIGIT ;
 fragment StringDQ : '"' StringContentDQ*? '"' ;
-fragment StringContentDQ : ~('\\' | '"' | '\n' | '\r' | '$') | '\\' ~('\n' | '\r') | StringDQ | '${' StringContentDQ*? '}' | '$' { CheckNotOpenBrace() }? ;
+fragment StringContentDQ : ~('\\' | '"' | '\n' | '\r' | '$') | '\\' ~('\n' | '\r') | StringDQ | '${' StringContentDQ*? '}' | '$' { this.CheckNotOpenBrace() }? ;
 fragment StringSQ : '\'' StringContentSQ*? '\'' ;
-fragment StringContentSQ : ~('\\' | '\'' | '\n' | '\r' | '$') | '\\' ~('\n' | '\r') | StringSQ | '${' StringContentSQ*? '}' | '$' { CheckNotOpenBrace() }? ;
+fragment StringContentSQ : ~('\\' | '\'' | '\n' | '\r' | '$') | '\\' ~('\n' | '\r') | StringSQ | '${' StringContentSQ*? '}' | '$' { this.CheckNotOpenBrace() }? ;
 fragment StringContentTDQ : ~('\\' | '"') | '"' ~'"' | '""' ~'"' ;
 fragment StringContentTSQ : '\'' ~'\'' | '\'\'' ~'\'' | . ;
 fragment ESCAPE_SEQUENCE : '\n' | '\r' | '\\f' | '\\b' | '\t' | '\\v' | '\\x' HEX_DIGIT HEX_DIGIT | '\\u' HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT | '\\u{' HEX_DIGIT_SEQUENCE '}' ;

dart2/Dart2Parser.g4

@@ -33,10 +33,10 @@ argumentList : namedArgument ( C namedArgument )* | expressionList ( C namedArgu
 argumentPart : typeArguments? arguments ;
 arguments : OP ( argumentList C? )? CP ;
 asOperator : AS_ ;
-assertion : ASSERT_ OP expression ( C expression )? C? CP ;
+assertion : ASSERT_ OP expr ( C expr )? C? CP ;
 assertStatement : assertion SC ;
 assignableExpression : primary assignableSelectorPart | SUPER_ unconditionalAssignableSelector | identifier ;
-assignableSelector : unconditionalAssignableSelector | QUD identifier | QU OB expression CB ;
+assignableSelector : unconditionalAssignableSelector | QUD identifier | QU OB expr CB ;
 assignableSelectorPart : selector* assignableSelector ;
 assignmentOperator : EQ | compoundAssignmentOperator ;
 awaitExpression : AWAIT_ unaryExpression ;
@@ -52,12 +52,12 @@ cascade : cascade DD cascadeSection | conditionalExpression ( QUDD | DD ) cascad
 cascadeAssignment : assignmentOperator expressionWithoutCascade ;
 cascadeSection : cascadeSelector cascadeSectionTail ;
 cascadeSectionTail : cascadeAssignment | selector* ( assignableSelector cascadeAssignment )? ;
-cascadeSelector : OB expression CB | identifier ;
+cascadeSelector : OB expr CB | identifier ;
 catchPart : CATCH_ OP identifier ( C identifier )? CP ;
 classDeclaration : ABSTRACT_? CLASS_ typeIdentifier typeParameters? superclass? interfaces? OBC ( metadata classMemberDeclaration )* CBC | ABSTRACT_? CLASS_ mixinApplicationClass ;
 classMemberDeclaration : declaration SC | methodSignature functionBody ;
 combinator : SHOW_ identifierList | HIDE_ identifierList ;
-compilationUnit: (libraryDeclaration | partDeclaration | expression | statement) EOF ;
+compilationUnit: (libraryDeclaration | partDeclaration | expr | statement) EOF ;
 compoundAssignmentOperator : STE | SE | SQSE | PE | PLE | ME | LTLTE | GT GT GT EQ | GT GT EQ | AE | CIRE | POE | QUQUEQ ;
 conditionalExpression : ifNullExpression ( QU expressionWithoutCascade CO expressionWithoutCascade )? ;
 configurableUri : uri configurationUri* ;
@@ -72,20 +72,20 @@ continueStatement : CONTINUE_ identifier? SC ;
 declaration :ABSTRACT_? ( EXTERNAL_ factoryConstructorSignature | EXTERNAL_ constantConstructorSignature | EXTERNAL_ constructorSignature | ( EXTERNAL_ STATIC_? )? getterSignature | ( EXTERNAL_ STATIC_? )? setterSignature | ( EXTERNAL_ STATIC_? )? functionSignature | EXTERNAL_? operatorSignature | STATIC_ CONST_ type? staticFinalDeclarationList | STATIC_ FINAL_ type? staticFinalDeclarationList | STATIC_ LATE_ FINAL_ type? initializedIdentifierList | STATIC_ LATE_? varOrType initializedIdentifierList | COVARIANT_ LATE_ FINAL_ type? identifierList | COVARIANT_ LATE_? varOrType initializedIdentifierList | LATE_? FINAL_ type? initializedIdentifierList | LATE_? varOrType initializedIdentifierList | redirectingFactoryConstructorSignature | constantConstructorSignature ( redirection | initializers )? | constructorSignature ( redirection | initializers )? );
 declaredIdentifier : COVARIANT_? finalConstVarOrType identifier ;
 defaultCase : label* DEFAULT_ CO statements ;
-defaultFormalParameter : normalFormalParameter ( EQ expression )? ;
-defaultNamedParameter : metadata REQUIRED_? normalFormalParameterNoMetadata ( ( EQ | CO ) expression )? ;
-doStatement : DO_ statement WHILE_ OP expression CP SC ;
+defaultFormalParameter : normalFormalParameter ( EQ expr )? ;
+defaultNamedParameter : metadata REQUIRED_? normalFormalParameterNoMetadata ( ( EQ | CO ) expr )? ;
+doStatement : DO_ statement WHILE_ OP expr CP SC ;
 dottedIdentifierList : identifier ( D identifier )* ;
 element : expressionElement | mapElement | spreadElement | ifElement | forElement ;
 elements : element ( C element )* C? ;
 enumEntry : metadata identifier ;
 enumType : ENUM_ identifier OBC enumEntry ( C enumEntry )* C? CBC ;
 equalityExpression : relationalExpression ( equalityOperator relationalExpression )? | SUPER_ equalityOperator relationalExpression ;
 equalityOperator : EE | NE ;
-expression : assignableExpression assignmentOperator expression | conditionalExpression | cascade | throwExpression ;
-expressionElement : expression ;
-expressionList : expression ( C expression )* ;
-expressionStatement : expression? SC ;
+expr : assignableExpression assignmentOperator expr | conditionalExpression | cascade | throwExpression ;
+expressionElement : expr ;
+expressionList : expr ( C expr )* ;
+expressionStatement : expr? SC ;
 expressionWithoutCascade : assignableExpression assignmentOperator expressionWithoutCascade | conditionalExpression | throwExpressionWithoutCascade ;
 extensionDeclaration : EXTENSION_ identifier? typeParameters? ON_ type OBC ( metadata classMemberDeclaration )* CBC ;
 factoryConstructorSignature : CONST_? FACTORY_ constructorName formalParameterList ;
@@ -94,14 +94,14 @@ fieldInitializer : ( THIS_ D )? identifier EQ initializerExpression ;
 finalConstVarOrType : LATE_? FINAL_ type? | CONST_ type? | LATE_? varOrType ;
 finallyPart : FINALLY_ block ;
 forElement : AWAIT_? FOR_ OP forLoopParts CP element ;
-forInitializerStatement : localVariableDeclaration | expression? SC ;
-forLoopParts : forInitializerStatement expression? SC expressionList? | metadata declaredIdentifier IN_ expression | identifier IN_ expression ;
+forInitializerStatement : localVariableDeclaration | expr? SC ;
+forLoopParts : forInitializerStatement expr? SC expressionList? | metadata declaredIdentifier IN_ expr | identifier IN_ expr ;
 formalParameterList : OP CP | OP normalFormalParameters C? CP | OP normalFormalParameters C optionalOrNamedFormalParameters CP | OP optionalOrNamedFormalParameters CP ;
 formalParameterPart : typeParameters? formalParameterList ;
 forStatement : AWAIT_? FOR_ OP forLoopParts CP statement ;
-functionBody :NATIVE_ stringLiteral? SC |  ASYNC_? EG expression SC | ( ASYNC_ ST? | SYNC_ ST )? block ;
+functionBody :NATIVE_ stringLiteral? SC |  ASYNC_? EG expr SC | ( ASYNC_ ST? | SYNC_ ST )? block ;
 functionExpression : formalParameterPart functionExpressionBody ;
-functionExpressionBody : ASYNC_? EG expression | ( ASYNC_ ST? | SYNC_ ST )? block ;
+functionExpressionBody : ASYNC_? EG expr | ( ASYNC_ ST? | SYNC_ ST )? block ;
 functionFormalParameter : COVARIANT_? type? identifier formalParameterPart QU? ;
 functionPrefix : type? identifier ;
 functionSignature : type? identifier formalParameterPart ;
@@ -112,22 +112,22 @@ functionTypeTails : functionTypeTail QU? functionTypeTails | functionTypeTail ;
 getterSignature : type? GET_ identifier ;
 identifier : IDENTIFIER | ABSTRACT_ | AS_ | COVARIANT_ | DEFERRED_ | DYNAMIC_ | EXPORT_ | EXTERNAL_ | EXTENSION_ | FACTORY_ | FUNCTION_ | GET_ | IMPLEMENTS_ | IMPORT_ | INTERFACE_ | LATE_ | LIBRARY_ | MIXIN_ | OPERATOR_ | PART_ | REQUIRED_ | SET_ | STATIC_ | TYPEDEF_ | FUNCTION_ | ASYNC_ | HIDE_ | OF_ | ON_ | SHOW_ | SYNC_ | AWAIT_ | YIELD_ | DYNAMIC_ | NATIVE_ ;
 identifierList : identifier ( C identifier )* ;
-ifElement : IF_ OP expression CP element ( ELSE_ element )? ;
+ifElement : IF_ OP expr CP element ( ELSE_ element )? ;
 ifNullExpression : logicalOrExpression ( QUQU logicalOrExpression )* ;
-ifStatement : IF_ OP expression CP statement ( ELSE_ statement )? ;
+ifStatement : IF_ OP expr CP statement ( ELSE_ statement )? ;
 importOrExport : libraryImport | libraryExport ;
 importSpecification : IMPORT_ configurableUri ( DEFERRED_? AS_ identifier )? combinator* SC ;
 incrementOperator : PLPL | MM ;
-initializedIdentifier : identifier ( EQ expression )? ;
+initializedIdentifier : identifier ( EQ expr )? ;
 initializedIdentifierList : initializedIdentifier ( C initializedIdentifier )* ;
-initializedVariableDeclaration : declaredIdentifier ( EQ expression )? ( C initializedIdentifier )* ;
+initializedVariableDeclaration : declaredIdentifier ( EQ expr )? ( C initializedIdentifier )* ;
 initializerExpression : conditionalExpression | cascade ;
 initializerListEntry : SUPER_ arguments | SUPER_ D identifier arguments | fieldInitializer | assertion ;
 initializers : CO initializerListEntry ( C initializerListEntry )* ;
 interfaces : IMPLEMENTS_ typeNotVoidList ;
 isOperator : IS_ NOT? ;
 label : identifier CO ;
-letExpression : LET_ staticFinalDeclarationList IN_ expression ;
+letExpression : LET_ staticFinalDeclarationList IN_ expr ;
 libraryDeclaration :  libraryName? importOrExport* partDirective* ( metadata topLevelDeclaration )*  ;
 
 libraryExport : metadata EXPORT_ configurableUri combinator* SC ;
@@ -139,7 +139,7 @@ localFunctionDeclaration : metadata functionSignature functionBody ;
 localVariableDeclaration : metadata initializedVariableDeclaration SC ;
 logicalAndExpression : equalityExpression ( AA equalityExpression )* ;
 logicalOrExpression : logicalAndExpression ( PP logicalAndExpression )* ;
-mapElement : expression CO expression ;
+mapElement : expr CO expr ;
 metadata : ( AT metadatum )* ;
 metadatum : identifier | qualifiedName | constructorDesignation arguments ;
 methodSignature : constructorSignature initializers? | factoryConstructorSignature | STATIC_? functionSignature | STATIC_? getterSignature | STATIC_? setterSignature | operatorSignature ;
@@ -151,7 +151,7 @@ mixins : WITH_ typeNotVoidList ;
 multilineString : MultiLineString;
 multiplicativeExpression : unaryExpression ( multiplicativeOperator unaryExpression )* | SUPER_ ( multiplicativeOperator unaryExpression )+ ;
 multiplicativeOperator : ST | SL | PC | SQS ;
-namedArgument : label expression ;
+namedArgument : label expr ;
 namedFormalParameters : OBC defaultNamedParameter ( C defaultNamedParameter )* C? CBC ;
 namedParameterType : metadata REQUIRED_? typedIdentifier ;
 namedParameterTypes : OBC namedParameterType ( C namedParameterType )* C? CBC ;
@@ -179,34 +179,34 @@ partHeader : metadata PART_ OF_ ( dottedIdentifierList | uri ) SC ;
 postfixExpression : assignableExpression postfixOperator | primary selector* ;
 postfixOperator : incrementOperator ;
 prefixOperator : minusOperator | negationOperator | tildeOperator ;
-primary : thisExpression | SUPER_ unconditionalAssignableSelector | SUPER_ argumentPart | functionExpression | literal | identifier | newExpression | constObjectExpression | constructorInvocation | OP expression CP ;
+primary : thisExpression | SUPER_ unconditionalAssignableSelector | SUPER_ argumentPart | functionExpression | literal | identifier | newExpression | constObjectExpression | constructorInvocation | OP expr CP ;
 qualifiedName : typeIdentifier D identifier | typeIdentifier D typeIdentifier D identifier ;
 redirectingFactoryConstructorSignature : CONST_? FACTORY_ constructorName formalParameterList EQ constructorDesignation ;
 redirection : CO THIS_ ( D identifier )? arguments ;
 relationalExpression : bitwiseOrExpression ( typeTest | typeCast | relationalOperator bitwiseOrExpression )? | SUPER_ relationalOperator bitwiseOrExpression ;
 relationalOperator : GT EQ | GT | LTE | LT ;
 reserved_word : ASSERT_ | BREAK_ | CASE_ | CATCH_ | CLASS_ | CONST_ | CONTINUE_ | DEFAULT_ | DO_ | ELSE_ | ENUM_ | EXTENDS_ | FALSE_ | FINAL_ | FINALLY_ | FOR_ | IF_ | IN_ | IS_ | NEW_ | NULL_ | RETHROW_ | RETURN_ | SUPER_ | SWITCH_ | THIS_ | THROW_ | TRUE_ | TRY_ | VAR_ | VOID_ | WHILE_ | WITH_ ;
 rethrowStatement : RETHROW_ SC ;
-returnStatement : RETURN_ expression? SC ;
+returnStatement : RETURN_ expr? SC ;
 selector : NOT | assignableSelector | argumentPart ;
 setOrMapLiteral : CONST_? typeArguments? OBC elements? CBC ;
 setterSignature : type? SET_ identifier formalParameterList ;
 shiftExpression : additiveExpression ( shiftOperator additiveExpression )* | SUPER_ ( shiftOperator additiveExpression )+ ;
 shiftOperator : LTLT | GT GT GT | GT GT ;
 simpleFormalParameter : declaredIdentifier | COVARIANT_? identifier ;
 singleLineString : SingleLineString;
-spreadElement : ( DDD | DDDQ ) expression ;
+spreadElement : ( DDD | DDDQ ) expr ;
 statement : label* nonLabelledStatement ;
 statements : statement* ;
-staticFinalDeclaration : identifier EQ expression ;
+staticFinalDeclaration : identifier EQ expr ;
 staticFinalDeclarationList : staticFinalDeclaration ( C staticFinalDeclaration )* ;
 stringLiteral : ( multilineString | singleLineString )+ ;
 superclass : EXTENDS_ typeNotVoid mixins? | mixins ;
-switchCase : label* CASE_ expression CO statements ;
-switchStatement : SWITCH_ OP expression CP OBC switchCase* defaultCase? CBC ;
+switchCase : label* CASE_ expr CO statements ;
+switchStatement : SWITCH_ OP expr CP OBC switchCase* defaultCase? CBC ;
 symbolLiteral : PO ( identifier ( D identifier )* | operator | VOID_ ) ;
 thisExpression : THIS_ ;
-throwExpression : THROW_ expression ;
+throwExpression : THROW_ expr ;
 throwExpressionWithoutCascade : THROW_ expressionWithoutCascade ;
 tildeOperator : SQUIG ;
 topLevelDeclaration : classDeclaration | mixinDeclaration | extensionDeclaration | enumType | typeAlias | EXTERNAL_ functionSignature SC | EXTERNAL_ getterSignature SC | EXTERNAL_ setterSignature SC | functionSignature functionBody | getterSignature functionBody | setterSignature functionBody | ( FINAL_ | CONST_ ) type? staticFinalDeclarationList SC | LATE_ FINAL_ type? initializedIdentifierList SC | LATE_? varOrType initializedIdentifierList SC ;
@@ -228,10 +228,10 @@ typeParameter : metadata identifier ( EXTENDS_ typeNotVoid )? ;
 typeParameters : LT typeParameter ( C typeParameter )* GT ;
 typeTest : isOperator typeNotVoid ;
 unaryExpression : prefixOperator unaryExpression | awaitExpression | postfixExpression | ( minusOperator | tildeOperator ) SUPER_ | incrementOperator assignableExpression ;
-unconditionalAssignableSelector : OB expression CB | D identifier ;
+unconditionalAssignableSelector : OB expr CB | D identifier ;
 uri : stringLiteral ;
 uriTest : dottedIdentifierList ( EE stringLiteral )? ;
 varOrType : VAR_ | type ;
-whileStatement : WHILE_ OP expression CP statement ;
-yieldEachStatement : YIELD_ ST expression SC ;
-yieldStatement : YIELD_ expression SC ;
+whileStatement : WHILE_ OP expr CP statement ;
+yieldEachStatement : YIELD_ ST expr SC ;
+yieldStatement : YIELD_ expr SC ;

dart2/Go/dart2_lexer_base.go

@@ -0,0 +1,13 @@
+package parser
+
+import (
+    "github.com/antlr4-go/antlr/v4"
+)
+
+type Dart2LexerBase struct {
+    *antlr.BaseLexer
+}
+
+func (l *Dart2LexerBase) CheckNotOpenBrace() bool {
+    return l.GetInputStream().(antlr.CharStream).LA(1) != '{';
+}

dart2/Go/transformGrammar.py

@@ -0,0 +1,56 @@
+import sys, os, re, shutil
+from glob import glob
+from pathlib import Path
+
+def main(argv):
+    for file in glob("./parser/*Lexer.g4"):
+        fix_lexer(file)
+    for file in glob("./parser/*Parser.g4"):
+        fix_parser(file)
+
+def fix_lexer(file_path):
+    print("Altering " + file_path)
+    if not os.path.exists(file_path):
+        print(f"Could not find file: {file_path}")
+        sys.exit(1)
+    parts = os.path.split(file_path)
+    file_name = parts[-1]
+
+    shutil.move(file_path, file_path + ".bak")
+    input_file = open(file_path + ".bak",'r')
+    output_file = open(file_path, 'w')
+    for x in input_file:
+        if 'this.' in x and '}?' in x:
+            x = x.replace('this.', 'p.')
+        elif 'this.' in x:
+            x = x.replace('this.', 'l.')
+        output_file.write(x)
+        output_file.flush()
+
+    print("Writing ...")
+    input_file.close()
+    output_file.close()
+
+def fix_parser(file_path):
+    print("Altering " + file_path)
+    if not os.path.exists(file_path):
+        print(f"Could not find file: {file_path}")
+        sys.exit(1)
+    parts = os.path.split(file_path)
+    file_name = parts[-1]
+
+    shutil.move(file_path, file_path + ".bak")
+    input_file = open(file_path + ".bak",'r')
+    output_file = open(file_path, 'w')
+    for x in input_file:
+        if 'this.' in x:
+            x = x.replace('this.', 'p.')
+        output_file.write(x)
+        output_file.flush()
+
+    print("Writing ...")
+    input_file.close()
+    output_file.close()
+
+if __name__ == '__main__':
+    main(sys.argv)

dart2/Java/Dart2LexerBase.java

@@ -4,11 +4,11 @@
 public abstract class Dart2LexerBase extends Lexer
 {
     protected Dart2LexerBase(CharStream input) {
-	super(input);
+        super(input);
     }
 
     protected boolean CheckNotOpenBrace()
     {
-	return _input.LA(1) != '{';
+        return _input.LA(1) != '{';
     }
 }