// Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

library dart_printer_test;

import 'dart:mirrors';
import 'package:expect/expect.dart';
import 'package:compiler/src/constants/values.dart';
import 'package:compiler/src/dart_backend/backend_ast_nodes.dart';
import 'package:compiler/src/dart_backend/backend_ast_to_frontend_ast.dart'
    show TreePrinter;
import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
import 'package:compiler/src/diagnostics/messages.dart';
import 'package:compiler/src/diagnostics/spannable.dart' show Spannable;
import 'package:compiler/src/parser/listener.dart';
import 'package:compiler/src/parser/parser.dart';
import 'package:compiler/src/scanner/scanner.dart';
import 'package:compiler/src/tokens/token.dart';
import 'package:compiler/src/tokens/token_constants.dart';
import 'package:compiler/src/io/source_file.dart';
import 'package:compiler/src/string_validator.dart';
import 'package:compiler/src/tree/tree.dart' show DartString;
import 'package:compiler/src/tree/tree.dart' as tree;
import '../options_helper.dart';

/// For debugging the [AstBuilder] stack. Prints information about [x].
void show(x) {
  StringBuffer buf = new StringBuffer();
  Unparser unparser = new Unparser(buf);
  void unparse(x) {
    if (x is Expression)
      unparser.writeExpression(x);
    else if (x is TypeAnnotation)
      unparser.writeType(x);
    else if (x is Statement)
      unparser.writeStatement(x);
    else if (x is List) {
      buf.write('[');
      bool first = true;
      for (var y in x) {
        if (first)
          first = false;
        else
          buf.write(', ');
        unparse(y);
      }
      buf.write(']');
    }
  }
  unparse(x);
  print("${x.runtimeType}: ${buf.toString()}");
}

class PrintDiagnosticListener implements DiagnosticReporter {
  void log(message) {
    print(message);
  }

  void internalError(Spannable spannable, message) {
    print(message);
  }

  SourceSpan spanFromSpannable(Spannable node) {
    return new SourceSpan(null, 0, 0);
  }

  void reportFatalError(Spannable node, MessageKind errorCode,
                        [Map arguments = const {}]) {
    print(errorCode);
    throw new Error();
  }

  void reportError(Spannable node, MessageKind errorCode,
                   [Map arguments = const {}]) {
    print(errorCode);
  }

  void reportWarning(Spannable node, MessageKind errorCode,
                     [Map arguments = const {}]) {
    print(errorCode);
  }

  void reportHint(Spannable node, MessageKind errorCode,
                  [Map arguments = const {}]) {
    print(errorCode);
  }

  void reportInfo(Spannable node, MessageKind errorCode,
                  [Map arguments = const {}]) {
    print(errorCode);
  }

  withCurrentElement(element, f()) {
    f();
  }
}

class AstBuilder extends Listener {
  final List stack = [];
  final StringValidator stringValidator
         = new StringValidator(new PrintDiagnosticListener());

  String asName(e) {
    if (e is Identifier)
      return e.name;
    else if (e == null)
      return null;
    else
      throw 'Expression is not a name: ${e.runtimeType}';
  }

  TypeAnnotation asType(x) {
    if (x is TypeAnnotation)
      return x;
    if (x is Identifier)
      return new TypeAnnotation(x.name);
    if (x == null)
      return null;
    else
      throw "Not a type: ${x.runtimeType}";
  }

  Parameter asParameter(x) {
    if (x is Parameter)
      return x;
    if (x is Identifier)
      return new Parameter(x.name);
    else
      throw "Not a parameter: ${x.runtimeType}";
  }

  void push(node) {
    stack.add(node);
  }
  dynamic peek() {
    return stack.last;
  }
  dynamic pop([coerce(x) = null]) {
    var x = stack.removeLast();
    if (coerce != null)
      return coerce(x);
    else
      return x;
  }
  List popList(int count, [List result, coerce(x) = null]) {
    if (result == null)
      result = <Node>[];
    for (int i=0; i<count; i++) {
      var x = stack[stack.length-count+i];
      if (coerce != null) {
        x = coerce(x);
      }
      result.add(x);
    }
    stack.removeRange(stack.length-count, stack.length);
    return result;
  }
  popTypeAnnotation() {
    List<TypeAnnotation> args = pop();
    if (args == null)
      return null;
    String name = pop(asName);
    return new TypeAnnotation(name, args);
  }

  // EXPRESSIONS
  endCascade() {
    throw "Cascade not supported yet";
  }
  endIdentifierList(int count) {
    push(popList(count, <Identifier>[]));
  }
  endTypeList(int count) {
    push(popList(count, <TypeAnnotation>[], asType));
  }
  beginLiteralString(Token token) {
    String source = token.value;
    tree.StringQuoting quoting = StringValidator.quotingFromString(source);
    push(quoting);
    push(token); // collect token at the end
  }
  handleStringPart(Token token) {
    push(token); // collect token at the end
  }
  endLiteralString(int interpCount) {
    List parts = popList(2 * interpCount + 1, []);
    tree.StringQuoting quoting = pop();
    List<Expression> members = <Expression>[];
    for (var i=0; i<parts.length; i++) {
      var part = parts[i];
      if (part is Expression) {
        members.add(part);
      } else {
        assert(part is Token);
        DartString str = stringValidator.validateInterpolationPart(
            part as Token,
            quoting,
            isFirst: i == 0,
            isLast: i == parts.length - 1);
        members.add(new Literal(new StringConstantValue(str)));
      }
    }
    push(new StringConcat(members));
  }
  handleStringJuxtaposition(int litCount) {
    push(new StringConcat(popList(litCount, <Expression>[])));
  }
  endArguments(int count, begin, end) {
    push(popList(count, <Argument>[]));
  }
  handleNoArguments(token) {
    push(null);
  }
  handleNoTypeArguments(token) {
    push(<TypeAnnotation>[]);
  }
  endTypeArguments(int count, t, y) {
    List<TypeAnnotation> args = <TypeAnnotation>[];
    for (var i=0; i<count; i++) {
      args.add(popTypeAnnotation());
    }
    push(args.reversed.toList(growable:false));
  }
  handleVoidKeyword(token) {
    push(new Identifier("void"));
    push(<TypeAnnotation>[]); // prepare for popTypeAnnotation
  }
  handleQualified(Token period) {
    String last = pop(asName);
    String first = pop(asName);
    push(new Identifier('$first.$last'));
  }
  endSend(t) {
    List<Argument> arguments = pop();
    pop(); // typeArguments
    if (arguments == null)
      return; // not a function call
    Expression selector = pop();
    push(new CallFunction(selector, arguments));
  }
  endThrowExpression(t, tt) {
    push(new Throw(pop()));
  }
  handleAssignmentExpression(Token token) {
    Expression right = pop();
    Expression left = pop();
    push(new Assignment(left, token.value, right));
  }
  handleBinaryExpression(Token token) {
    Expression right = pop();
    Receiver left = pop();
    String tokenString = token.stringValue;
    if (tokenString == '.') {
      if (right is CallFunction) {
        String name = (right.callee as Identifier).name;
        push(new CallMethod(left, name, right.arguments));
      } else {
        push(new FieldExpression(left, (right as Identifier).name));
      }
    } else {
      push(new BinaryOperator(left, tokenString, right));
    }
  }
  handleConditionalExpression(question, colon) {
    Expression elseExpression = pop();
    Expression thenExpression = pop();
    Expression condition = pop();
    push(new Conditional(condition, thenExpression, elseExpression));
  }
  handleIdentifier(Token t) {
    push(new Identifier(t.value));
  }
  handleOperator(t) {
    push(new Identifier(t.value));
  }
  handleIndexedExpression(open, close) {
    Expression index = pop();
    Receiver object = pop();
    push(new IndexExpression(object, index));
  }
  handleIsOperator(operathor, not, endToken) {
    TypeAnnotation type = popTypeAnnotation();
    Expression exp = pop();
    TypeOperator r = new TypeOperator(exp, 'is', type);
    if (not != null) {
      push(new UnaryOperator('!', r));
    } else {
      push(r);
    }
  }
  handleAsOperator(operathor, endToken) {
    TypeAnnotation type = popTypeAnnotation();
    Expression exp = pop();
    push(new TypeOperator(exp, 'as', type));
  }
  handleLiteralBool(Token t) {
    bool value = t.value == 'true';
    push(new Literal(
        value ? new TrueConstantValue() : new FalseConstantValue()));
  }
  handleLiteralDouble(t) {
    push(new Literal(new DoubleConstantValue(double.parse(t.value))));
  }
  handleLiteralInt(Token t) {
    push(new Literal(new IntConstantValue(int.parse(t.value))));
  }
  handleLiteralNull(t) {
    push(new Literal(new NullConstantValue()));
  }
  endLiteralSymbol(Token hash, int idCount) {
    List<Identifier> ids = popList(idCount, <Identifier>[]);
    push(new LiteralSymbol(ids.map((id) => id.name).join('.')));
  }
  handleLiteralList(int count, begin, constKeyword, end) {
    List<Expression> exps = popList(count, <Expression>[]);
    List<TypeAnnotation> types = pop();
    assert(types.length <= 1);
    push(new LiteralList(exps,
      isConst: constKeyword != null,
      typeArgument: types.length == 0 ? null : types[0]
    ));
  }
  handleLiteralMap(int count, begin, constKeyword, end) {
    List<LiteralMapEntry> entries = popList(count, <LiteralMapEntry>[]);
    List<TypeAnnotation> types = pop();
    assert(types.length == 0 || types.length == 2);
    push(new LiteralMap(entries,
        isConst: constKeyword != null,
        typeArguments: types
    ));
  }
  endLiteralMapEntry(colon, endToken) {
    Expression value = pop();
    Expression key = pop();
    push(new LiteralMapEntry(key,value));
  }
  handleNamedArgument(colon) {
    Expression exp = pop();
    Identifier name = pop();
    push(new NamedArgument(name.name, exp));
  }
  endConstructorReference(Token start, Token period, Token end) {
    if (period == null) {
      push(null); // indicate missing constructor name
    }
  }
  handleNewExpression(t) {
    List<Argument> args = pop();
    String constructorName = pop(asName);
    TypeAnnotation type = popTypeAnnotation();
    push(new CallNew(type, args, constructorName: constructorName));
  }
  handleConstExpression(t) {
    List<Argument> args = pop();
    String constructorName = pop(asName);
    TypeAnnotation type = popTypeAnnotation();
    push(new CallNew(type, args, constructorName: constructorName,
                     isConst:true));
  }
  handleParenthesizedExpression(t) {
    // do nothing, just leave expression on top of stack
  }
  handleSuperExpression(t) {
    push(new SuperReceiver());
  }
  handleThisExpression(t) {
    push(new This());
  }
  handleUnaryPostfixAssignmentExpression(Token t) {
    push(new Increment.postfix(pop(), t.value));
  }
  handleUnaryPrefixAssignmentExpression(Token t) {
    push(new Increment.prefix(pop(), t.value));
  }
  handleUnaryPrefixExpression(Token t) {
    push(new UnaryOperator(t.value, pop()));
  }

  handleFunctionTypedFormalParameter(tok) {
    // handled in endFormalParameter
  }
  endFormalParameter(thisKeyword) {
    Expression defaultValue = null;
    var x = pop();
    if (x is DefaultValue) {
      defaultValue = x.expression;
      x = pop();
    }
    if (x is Parameters) {
      String name = pop(asName);
      TypeAnnotation returnType = popTypeAnnotation();
      push(new Parameter.function(name, returnType, x, defaultValue));
    } else {
      String name = asName(x);
      TypeAnnotation type = popTypeAnnotation();
      push(new Parameter(name, type:type, defaultValue:defaultValue));
    }
  }
  handleValuedFormalParameter(eq, tok) {
    push(new DefaultValue(pop()));
  }
  endOptionalFormalParameters(int count, begin, end) {
    bool isNamed = end.value == '}';
    push(popList(count, <Parameter>[], asParameter));
    push(isNamed); // Indicate optional parameters to endFormalParameters.
  }
  endFormalParameters(count, begin, end) {
    if (count == 0) {
      push(new Parameters([]));
      return;
    }
    var last = pop();   // Detect if optional parameters are present.
    if (last is bool) { // See endOptionalFormalParameters.
      List<Parameter> optional = pop();
      List<Parameter> required = popList(count-1, <Parameter>[], asParameter);
      push(new Parameters(required, optional, last));
    } else {
      // No optional parameters.
      List<Parameter> required = popList(count-1, <Parameter>[], asParameter);
      required.add(last);
      push(new Parameters(required));
    }
  }
  handleNoFormalParameters(tok) {
    push(new Parameters([]));
  }

  endUnnamedFunction(t) {
    Statement body = pop();
    Parameters parameters = pop();
    push(new FunctionExpression(parameters, body));
  }

  handleNoType(Token token) {
    push(null);
  }

  endReturnStatement(bool hasExpression, begin, end) {
    // This is also called for functions whose body is "=> expression"
    if (hasExpression) {
      push(new Return(pop()));
    } else {
      push(new Return());
    }
  }

  endExpressionStatement(Token token) {
    push(new ExpressionStatement(pop()));
  }

  endDoWhileStatement(Token doKeyword, Token whileKeyword, Token end) {
    Expression condition = pop();
    Statement body = pop();
    push(new DoWhile(body, condition));
  }

  endWhileStatement(Token whileKeyword, Token end) {
    Statement body = pop();
    Expression condition = pop();
    push(new While(condition, body));
  }

  endBlock(int count, Token begin, Token end) {
    push(new Block(popList(count, <Statement>[])));
  }

  endRethrowStatement(Token throwToken, Token endToken) {
    push(new Rethrow());
  }

  endTryStatement(int catchCount, Token tryKeyword, Token finallyKeyword) {
    Statement finallyBlock = null;
    if (finallyKeyword != null) {
      finallyBlock = pop();
    }
    List<CatchBlock> catchBlocks = popList(catchCount, <CatchBlock>[]);
    Statement tryBlock = pop();
    push(new Try(tryBlock, catchBlocks, finallyBlock));
  }

  void handleCatchBlock(Token onKeyword, Token catchKeyword) {
    Statement block = pop();
    String exceptionVar = null;
    String stackVar = null;
    if (catchKeyword != null) {
      Parameters params = pop();
      exceptionVar = params.requiredParameters[0].name;
      if (params.requiredParameters.length > 1) {
        stackVar = params.requiredParameters[1].name;
      }
    }
    TypeAnnotation type = onKeyword == null ? null : pop();
    push(new CatchBlock(block,
      onType: type,
      exceptionVar: exceptionVar,
      stackVar: stackVar
    ));
  }

  endSwitchStatement(Token switchKeyword, Token end) {
    List<SwitchCase> cases = pop();
    Expression expression = pop();
    push(new Switch(expression, cases));
  }

  endSwitchBlock(int caseCount, Token begin, Token end) {
    push(popList(caseCount, <SwitchCase>[]));
  }

  handleSwitchCase(int labelCount, int caseCount, Token defaultKeyword,
                   int statementCount, Token first, Token end) {
    List<Statement> statements = popList(statementCount, <Statement>[]);
    List<Expression> cases = popList(caseCount, <Expression>[]);
    if (defaultKeyword != null) {
      cases = null;
    }
    push(new SwitchCase(cases, statements));
  }

  handleCaseMatch(Token caseKeyword, Token colon) {
    // do nothing, leave case expression on stack
  }

  handleBreakStatement(bool hasTarget, Token breakKeyword, Token end) {
    String target = hasTarget ? pop(asName) : null;
    push(new Break(target));
  }

  handleContinueStatement(bool hasTarget, Token continueKeyword, Token end) {
    String target = hasTarget ? pop(asName) : null;
    push(new Continue(target));
  }

  handleEmptyStatement(Token token) {
    push(new EmptyStatement());
  }


  VariableDeclaration asVariableDeclaration(x) {
    if (x is VariableDeclaration)
      return x;
    if (x is Identifier)
      return new VariableDeclaration(x.name);
    throw "Not a variable definition: ${x.runtimeType}";
  }

  endVariablesDeclaration(int count, Token end) {
    List<VariableDeclaration> variables =
        popList(count, <VariableDeclaration>[], asVariableDeclaration);
    TypeAnnotation type = popTypeAnnotation();
    push(new VariableDeclarations(variables,
      type: type,
      isFinal: false, // TODO(asgerf): Parse modifiers.
      isConst: false
    ));
  }

  endInitializer(Token assign) {
    Expression init = pop();
    String name = pop(asName);
    push(new VariableDeclaration(name, init));
  }

  endIfStatement(Token ifToken, Token elseToken) {
    Statement elsePart = (elseToken == null) ? null : pop();
    Statement thenPart = pop();
    Expression condition = pop();
    push(new If(condition, thenPart, elsePart));
  }

  endForStatement(int updateCount, Token begin, Token end) {
    Statement body = pop();
    List<Expression> updates = popList(updateCount, <Expression>[]);
    ExpressionStatement condition = pop(); // parsed as expression statement
    Expression exp = condition == null ? null : condition.expression;
    Node initializer = pop();
    push(new For(initializer, exp, updates, body));
  }

  handleNoExpression(Token token) {
    push(null);
  }

  endForIn(Token await, Token begin, Token inKeyword, Token end) {
    Statement body = pop();
    Expression exp = pop();
    Node declaredIdentifier = pop();
    push(new ForIn(declaredIdentifier, exp, body));
  }

  handleAssertStatement(Token assertKeyword,
                        Token commaToken, Token semicolonToken) {
    Expression message;
    if (commaToken != null) message = pop();
    Expression exp = pop();
    var arguments = [exp];
    if (message != null) arguments.add(message);
    Expression call = new CallFunction(new Identifier("assert"), arguments);
    push(new ExpressionStatement(call));
  }

  endLabeledStatement(int labelCount) {
    Statement statement = pop();
    for (int i=0; i<labelCount; i++) {
      String label = pop(asName);
      statement = new LabeledStatement(label, statement);
    }
    push(statement);
  }

  endFunctionDeclaration(Token end) {
    Statement body = pop();
    Parameters parameters = pop();
    String name = pop(asName);
    TypeAnnotation returnType = popTypeAnnotation();
    push(new FunctionDeclaration(new FunctionExpression(parameters, body,
        name: name,
        returnType: returnType)));
  }

  endFunctionBody(int count, Token begin, Token end) {
    push(new Block(popList(count, <Statement>[])));
  }
}

class DefaultValue {
  final Expression expression;
  DefaultValue(this.expression);
}

/// Compares ASTs for structural equality.
void checkDeepEqual(x, y) {
  if (x is List && y is List) {
    if (x.length != y.length)
      return;
    for (var i=0; i<x.length; i++) {
      checkDeepEqual(x[i], y[i]);
    }
  }
  else if (x is Node && y is Node) {
    if (x.runtimeType != y.runtimeType)
      throw new Error();
    InstanceMirror xm = reflect(x);
    InstanceMirror ym = reflect(y);
    for (Symbol name in xm.type.instanceMembers.keys) {
      if (reflectClass(Object).declarations.containsKey(name)) {
        continue; // do not check things from Object, such as hashCode
      }
      MethodMirror mm = xm.type.instanceMembers[name];
      if (mm.isGetter) {
        var xv = xm.getField(name).reflectee;
        var yv = ym.getField(name).reflectee;
        checkDeepEqual(xv,yv);
      }
    }
  }
  else if (x is PrimitiveConstantValue && y is PrimitiveConstantValue) {
    checkDeepEqual(x.primitiveValue, y.primitiveValue);
  }
  else if (x is DartString && y is DartString) {
    if (x.slowToString() != y.slowToString()) {
      throw new Error();
    }
  }
  else {
    if (x != y) {
      throw new Error();
    }
  }
}

Expression parseExpression(String code) {
  SourceFile file = new StringSourceFile.fromName('', code);
  Scanner scan = new Scanner(file);
  Token tok = scan.tokenize();
  AstBuilder builder = new AstBuilder();
  Parser parser = new Parser(builder, new MockParserOptions());
  tok = parser.parseExpression(tok);
  if (builder.stack.length != 1 || tok.kind != EOF_TOKEN) {
    throw "Parse error in $code";
  }
  return builder.pop();
}
Statement parseStatement(String code) {
  SourceFile file = new StringSourceFile.fromName('', code);
  Scanner scan = new Scanner(file);
  Token tok = scan.tokenize();
  AstBuilder builder = new AstBuilder();
  Parser parser = new Parser(builder, new MockParserOptions());
  tok = parser.parseStatement(tok);
  if (builder.stack.length != 1 || tok.kind != EOF_TOKEN) {
    throw "Parse error in $code";
  }
  return builder.pop();
}

String unparseExpression(Expression exp) {
  StringBuffer buf = new StringBuffer();
  new Unparser(buf).writeExpression(exp);
  return buf.toString();
}
String unparseStatement(Statement stmt) {
  StringBuffer buf = new StringBuffer();
  new Unparser(buf).writeStatement(stmt);
  return buf.toString();
}

/// Converts [exp] to an instance of the frontend AST and unparses that.
String frontUnparseExpression(Expression exp) {
  tree.Node node = new TreePrinter().makeExpression(exp);
  return tree.unparse(node);
}
/// Converts [stmt] to an instance of the frontend AST and unparses that.
String frontUnparseStatement(Statement stmt) {
  tree.Node node = new TreePrinter().makeStatement(stmt);
  return tree.unparse(node);
}

/// Parses [code], unparses the resulting AST, then parses the unparsed text.
/// The ASTs from the first and second parse are then compared for structural
/// equality. Alternatively, if [expected] is not an empty string, the second
/// parse must match the AST of parsing [expected].
void checkFn(String code, String expected, Function parse, Function unparse) {
  var firstParse = parse(code);
  String unparsed = unparse(firstParse);
  try {
    var secondParse = parse(unparsed);
    var baseline = expected == "" ? firstParse : parse(expected);
    checkDeepEqual(baseline, secondParse);
  } catch (e, stack) {
    Expect.fail('"$code" was unparsed as "$unparsed"');
  }
}

void checkExpression(String code, [String expected="", String expected2=""]) {
  checkFn(code, expected, parseExpression, unparseExpression);
  checkFn(code, expected2, parseExpression, frontUnparseExpression);
}
void checkStatement(String code, [String expected="", String expected2=""]) {
  checkFn(code, expected, parseStatement, unparseStatement);
  checkFn(code, expected2, parseStatement, frontUnparseStatement);
}

void debugTokens(String code) {
  SourceFile file = new StringSourceFile.fromName('', code);
  Scanner scan = new Scanner(file);
  Token tok = scan.tokenize();
  while (tok.next != tok) {
    print(tok.toString());
    tok = tok.next;
  }
}

void main() {
  // To check if these tests are effective, one should manually alter
  // something in [Unparser] and see if a test fails.

  checkExpression(" a +  b  + c");
  checkExpression("(a +  b) + c");
  checkExpression(" a + (b  + c)");

  checkExpression(" a +  b  - c");
  checkExpression("(a +  b) - c");
  checkExpression(" a + (b  - c)");

  checkExpression(" a -  b  + c");
  checkExpression("(a -  b) + c");
  checkExpression(" a - (b  + c)");

  checkExpression(" a *  b  + c");
  checkExpression("(a *  b) + c");
  checkExpression(" a * (b  + c)");

  checkExpression(" a +  b  * c");
  checkExpression("(a +  b) * c");
  checkExpression(" a + (b  * c)");

  checkExpression(" a *  b  * c");
  checkExpression("(a *  b) * c");
  checkExpression(" a * (b  * c)");

  checkExpression("a is T");
  checkExpression("a is! T");
  checkExpression("!(a is T)");

  checkExpression("a is T.x");
  checkExpression("a is! T.x");
  checkExpression("!(a is T.x)");
  checkExpression("!(a is T).x");

  checkExpression("a as T.x");
  checkExpression("(a as T).x");

  checkExpression("a == b");
  checkExpression("a != b");
  checkExpression("!(a == b)", "a != b");

  checkExpression("a && b ? c : d");
  checkExpression("(a && b) ? c : d");
  checkExpression("a && (b ? c : d)");

  checkExpression("a || b ? c : d");
  checkExpression("(a || b) ? c : d");
  checkExpression("a || (b ? c : d)");

  checkExpression(" a ? b :  c && d");
  checkExpression(" a ? b : (c && d)");
  checkExpression("(a ? b :  c) && d");

  checkExpression(" a ? b : c = d");
  checkExpression(" a ? b : (c = d)");

  checkExpression("(a == b) == c");
  checkExpression("a == (b == c)");

  checkExpression(" a <  b  == c");
  checkExpression("(a <  b) == c");
  checkExpression(" a < (b  == c)");

  checkExpression(" a ==  b  < c");
  checkExpression("(a ==  b) < c");
  checkExpression(" a == (b  < c)");

  checkExpression("x.f()");
  checkExpression("(x.f)()");

  checkExpression("x.f()()");
  checkExpression("(x.f)()()");

  checkExpression("x.f().g()");
  checkExpression("(x.f)().g()");

  checkExpression("x.f()");
  checkExpression("x.f(1 + 2)");
  checkExpression("x.f(1 + 2, 3 + 4)");
  checkExpression("x.f(1 + 2, foo:3 + 4)");
  checkExpression("x.f(1 + 2, foo:3 + 4, bar: 5)");
  checkExpression("x.f(foo:3 + 4)");
  checkExpression("x.f(foo:3 + 4, bar: 5)");

  checkExpression("x.f.g.h");
  checkExpression("(x.f).g.h");
  checkExpression("(x.f.g).h");

  checkExpression(" a =  b  + c");
  checkExpression(" a = (b  + c)");
  checkExpression("(a =  b) + c");

  checkExpression("a + (b = c)");

  checkExpression("dx * dx + dy * dy < r * r",
                  "((dx * dx) + (dy * dy)) < (r * r)");
  checkExpression("mid = left + right << 1",
                  "mid = ((left + right) << 1)");
  checkExpression("a + b % c * -d ^  e - f  ~/ x & ++y / z++ | w > a ? b : c");
  checkExpression("a + b % c * -d ^ (e - f) ~/ x & ++y / z++ | w > a ? b : c");

  checkExpression("'foo'");
  checkExpression("'foo' 'bar'", "'foobar'");

  checkExpression("{}.length");
  checkExpression("{x: 1+2}.length");
  checkExpression("<String,int>{}.length");
  checkExpression("<String,int>{x: 1+2}.length");

  checkExpression("[].length");
  checkExpression("[1+2].length");
  checkExpression("<num>[].length");
  checkExpression("<num>[1+2].length");

  checkExpression("x + -y");
  checkExpression("x + --y");
  checkExpression("x++ + y");
  checkExpression("x + ++y");
  checkExpression("x-- - y");
  checkExpression("x-- - -y");
  checkExpression("x - --y");

  checkExpression("x && !y");
  checkExpression("!x && y");
  checkExpression("!(x && y)");

  checkExpression(" super +  1  * 2");
  checkExpression("(super +  1) * 2");
  checkExpression(" super + (1  * 2)");
  checkExpression("x + -super");
  checkExpression("x-- - -super");
  checkExpression("x - -super");
  checkExpression("x && !super");

  checkExpression("super.f(1, 2) + 3");
  checkExpression("super.f + 3");

  checkExpression(r"'foo\nbar'");
  checkExpression(r"'foo\r\nbar'");
  checkExpression(r"'foo\rbar'");
  checkExpression(r"'foo\'bar'");
  checkExpression(r"""'foo"bar'""");
  checkExpression(r"r'foo\nbar'");
  checkExpression("''");
  checkExpression("r''");

  var sq = "'";
  var dq = '"';
  checkExpression("'$dq$dq' \"$sq$sq\"");
  checkExpression("'$dq$dq$dq$dq' \"$sq$sq$sq$sq\"");
  checkExpression(r"'\$\$\$\$\$\$\$\$\$'");
  checkExpression("'$dq$dq$dq' '\\n\\n\\n\\n\\n\\n\\n\\n\\n\\n' \"$sq$sq$sq\"");
  checkExpression("'$dq$dq$dq' '\\r\\r\\r\\r\\r\\r\\r\\r\\r\\r' \"$sq$sq$sq\"");
  checkExpression("'$dq$dq$dq' '\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n' \"$sq$sq$sq\"");

  checkExpression(r"'$foo'");
  checkExpression(r"'${foo}x'");
  checkExpression(r"'${foo}x\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'");
  checkExpression(r"'abc' '${foo}' r'\\\\\\\'");

  checkExpression(r"'${$x}'");
  checkExpression(r"'${$x}y'");
  checkExpression("null + null");

  checkExpression("(x) => x",
                  '',
                  '(x){return x;}');
  checkStatement("fn(x) => x;",
                  '',
                  'fn(x){return x;}');

  checkExpression("throw x");
  checkStatement("throw x;");

  checkStatement("var x, y, z;");
  checkStatement("final x, y, z;");
  checkStatement("dynamic x, y, z;");
  checkStatement("String x, y, z;");
  checkStatement("List<int> x, y, z;");
  checkStatement("final dynamic x, y, z;");
  checkStatement("final String x, y, z;");
  checkStatement("final List<int> x, y, z;");

  checkStatement("var x = y, z;");
  checkStatement("var x, y = z;");
  checkStatement("var x = y = z;");

  // Note: We sometimes have to pass an expected string to account for
  //       block flattening which does not preserve structural AST equality
  checkStatement("if (x)   if (y) foo();   else bar();  ");
  checkStatement("if (x) { if (y) foo(); } else bar();  ");
  checkStatement("if (x) { if (y) foo();   else bar(); }",
                 "if (x)   if (y) foo();   else bar();  ");

  checkStatement("if (x) while (y)   if (z) foo();   else bar();  ");
  checkStatement("if (x) while (y) { if (z) foo(); } else bar();  ");
  checkStatement("if (x) while (y) { if (z) foo();   else bar(); }",
                 "if (x) while (y)   if (z) foo();   else bar();  ");

  checkStatement("{var x = 1; {var x = 2;} return x;}");
  checkStatement("{var x = 1; {x = 2;} return x;}",
                 "{var x = 1;  x = 2;  return x;}",
                 "{var x = 1;  x = 2;  return x;}");

  checkStatement("if (x) {var x = 1;}");

  checkStatement("({'foo': 1}).bar();");
  checkStatement("({'foo': 1}).length;");
  checkStatement("({'foo': 1}).length + 1;");
  checkStatement("({'foo': 1})['foo'].toString();");
  checkStatement("({'foo': 1})['foo'] = 3;");
  checkStatement("({'foo': 1}['foo']());");
  checkStatement("({'foo': 1}['foo'])();");
  checkStatement("({'foo': 1})['foo'].x++;");
  checkStatement("({'foo': 1}) is Map;");
  checkStatement("({'foo': 1}) as Map;");
  checkStatement("({'foo': 1}) is util.Map;");
  checkStatement("({'foo': 1}) + 1;");

  checkStatement("[1].bar();");
  checkStatement("1.bar();");
  checkStatement("'foo'.bar();");

  checkStatement("do while(x); while (y);");
  checkStatement("{do; while(x); while (y);}");

  checkStatement('switch(x) { case 1: case 2: return y; }');
  checkStatement('switch(x) { default: return y; }');
  checkStatement('switch(x) { case 1: x=y; default: return y; }');
  checkStatement('switch(x) { case 1: x=y; y=z; break; default: return y; }');

}