// Copyright (c) 2020, 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.

import 'package:_fe_analyzer_shared/src/util/libraries_specification.dart';
import 'package:expect/expect.dart';
import 'package:front_end/src/base/processed_options.dart';
import 'package:front_end/src/fasta/builder/type_alias_builder.dart';
import 'package:front_end/src/fasta/compiler_context.dart';
import 'package:front_end/src/fasta/dill/dill_library_builder.dart';
import 'package:front_end/src/fasta/dill/dill_loader.dart';
import 'package:front_end/src/fasta/dill/dill_target.dart';
import 'package:front_end/src/fasta/dill/dill_type_alias_builder.dart';
import 'package:front_end/src/fasta/kernel/collections.dart';
import 'package:front_end/src/fasta/kernel/forest.dart';
import 'package:front_end/src/fasta/kernel/internal_ast.dart';
import 'package:front_end/src/fasta/ticker.dart';
import 'package:front_end/src/fasta/uri_translator.dart';
import 'package:kernel/ast.dart';
import 'package:kernel/target/targets.dart';
import 'package:package_config/package_config.dart';

import 'text_representation_test.dart';

void testStatement(Statement node, String normal,
    {String? verbose, String? limited}) {
  Expect.stringEquals(normal, node.toText(normalStrategy),
      "Unexpected normal strategy text for ${node.runtimeType}");
  Expect.stringEquals(verbose ?? normal, node.toText(verboseStrategy),
      "Unexpected verbose strategy text for ${node.runtimeType}");
  Expect.stringEquals(limited ?? normal, node.toText(limitedStrategy),
      "Unexpected limited strategy text for ${node.runtimeType}");
}

void testExpression(Expression node, String normal,
    {String? verbose, String? limited}) {
  Expect.stringEquals(normal, node.toText(normalStrategy),
      "Unexpected normal strategy text for ${node.runtimeType}");
  Expect.stringEquals(verbose ?? normal, node.toText(verboseStrategy),
      "Unexpected verbose strategy text for ${node.runtimeType}");
  Expect.stringEquals(limited ?? normal, node.toText(limitedStrategy),
      "Unexpected limited strategy text for ${node.runtimeType}");
}

final Uri dummyUri = Uri.parse('test:dummy');

void main() {
  CompilerContext.runWithOptions(new ProcessedOptions(inputs: [dummyUri]),
      (_) async {
    _testVariableDeclarations();
    _testTryStatement();
    _testForInStatementWithSynthesizedVariable();
    _testSwitchCaseImpl();
    _testBreakStatementImpl();
    _testCascade();
    _testDeferredCheck();
    _testFactoryConstructorInvocationJudgment();
    _testTypeAliasedConstructorInvocation();
    _testTypeAliasedFactoryInvocation();
    _testFunctionDeclarationImpl();
    _testIfNullExpression();
    _testIntLiterals();
    _testInternalMethodInvocation();
    _testInternalPropertyGet();
    _testInternalPropertySet();
    _testExpressionInvocation();
    _testNamedFunctionExpressionJudgment();
    _testNullAwareMethodInvocation();
    _testNullAwarePropertyGet();
    _testNullAwarePropertySet();
    _testReturnStatementImpl();
    _testVariableDeclarationImpl();
    _testVariableGetImpl();
    _testLoadLibraryImpl();
    _testLoadLibraryTearOff();
    _testIfNullPropertySet();
    _testIfNullSet();
    _testCompoundExtensionSet();
    _testCompoundPropertySet();
    _testPropertyPostIncDec();
    _testLocalPostIncDec();
    _testStaticPostIncDec();
    _testSuperPostIncDec();
    _testIndexGet();
    _testIndexSet();
    _testSuperIndexSet();
    _testExtensionIndexSet();
    _testIfNullIndexSet();
    _testIfNullSuperIndexSet();
    _testIfNullExtensionIndexSet();
    _testCompoundIndexSet();
    _testNullAwareCompoundSet();
    _testNullAwareIfNullSet();
    _testCompoundSuperIndexSet();
    _testCompoundExtensionIndexSet();
    _testExtensionSet();
    _testNullAwareExtension();
    _testPropertySetImpl();
    _testExtensionTearOff();
    _testEqualsExpression();
    _testBinaryExpression();
    _testUnaryExpression();
    _testParenthesizedExpression();
    _testSpreadElement();
    _testIfElement();
    _testForElement();
    _testForInElement();
    _testSpreadMapEntry();
    _testIfMapEntry();
    _testForMapEntry();
    _testForInMapEntry();
  });
}

void _testVariableDeclarations() {
  testStatement(
      const Forest().variablesDeclaration(
          [new VariableDeclaration('a'), new VariableDeclaration('b')],
          dummyUri),
      '''
dynamic a, b;''');
  testStatement(
      const Forest().variablesDeclaration([
        new VariableDeclaration('a', type: const VoidType()),
        new VariableDeclaration('b', initializer: new NullLiteral())
      ], dummyUri),
      '''
void a, b = null;''');
}

void _testTryStatement() {
  Block emptyBlock1 = new Block([]);
  Block emptyBlock2 = new Block([]);
  Block returnBlock1 = new Block([new ReturnStatement()]);
  Block returnBlock2 = new Block([new ReturnStatement()]);
  Catch emptyCatchBlock =
      new Catch(new VariableDeclaration('e'), new Block([]));
  Catch emptyCatchBlockOnVoid = new Catch(
      new VariableDeclaration('e'), new Block([]),
      guard: const VoidType());
  Catch returnCatchBlock = new Catch(
      new VariableDeclaration('e'), new Block([new ReturnStatement()]));
  Catch returnCatchBlockOnVoid = new Catch(
      new VariableDeclaration('e'), new Block([new ReturnStatement()]),
      guard: const VoidType());

  testStatement(new TryStatement(emptyBlock1, [], emptyBlock2), '''
try {} finally {}''');

  testStatement(new TryStatement(returnBlock1, [], returnBlock2), '''
try {
  return;
} finally {
  return;
}''', limited: '''
try { return; } finally { return; }''');

  testStatement(new TryStatement(emptyBlock1, [emptyCatchBlock], null), '''
try {} catch (e) {}''');

  testStatement(
      new TryStatement(emptyBlock1, [emptyCatchBlockOnVoid], null), '''
try {} on void catch (e) {}''');

  testStatement(
      new TryStatement(
          emptyBlock1, [emptyCatchBlockOnVoid, emptyCatchBlock], null),
      '''
try {} on void catch (e) {} catch (e) {}''');

  testStatement(
      new TryStatement(
          emptyBlock1, [emptyCatchBlockOnVoid, emptyCatchBlock], emptyBlock2),
      '''
try {} on void catch (e) {} catch (e) {} finally {}''');

  testStatement(new TryStatement(returnBlock1, [returnCatchBlock], null), '''
try {
  return;
} catch (e) {
  return;
}''', limited: '''
try { return; } catch (e) { return; }''');

  testStatement(
      new TryStatement(returnBlock1, [returnCatchBlockOnVoid], null), '''
try {
  return;
} on void catch (e) {
  return;
}''',
      limited: '''
try { return; } on void catch (e) { return; }''');

  testStatement(
      new TryStatement(
          returnBlock1, [returnCatchBlockOnVoid, returnCatchBlock], null),
      '''
try {
  return;
} on void catch (e) {
  return;
} catch (e) {
  return;
}''',
      limited: '''
try { return; } on void catch (e) { return; } catch (e) { return; }''');

  testStatement(
      new TryStatement(returnBlock1, [returnCatchBlockOnVoid, returnCatchBlock],
          returnBlock2),
      '''
try {
  return;
} on void catch (e) {
  return;
} catch (e) {
  return;
} finally {
  return;
}''',
      limited: '''
try { return; } on void catch (e) { return; } catch (e) { return; } finally { return; }''');
}

void _testForInStatementWithSynthesizedVariable() {
  // TODO(johnniwinther): Test ForInStatementWithSynthesizedVariable
}

void _testSwitchCaseImpl() {
  Expression expression = new NullLiteral();
  Expression case0 = new IntLiteral(0);
  Expression case1 = new IntLiteral(1);
  Expression case2 = new IntLiteral(2);
  Block emptyBlock = new Block([]);
  Block returnBlock1 = new Block([new ReturnStatement()]);
  Block returnBlock2 = new Block([new ReturnStatement()]);

  testStatement(
      new SwitchStatement(expression, [
        new SwitchCaseImpl([case0], [0], emptyBlock, hasLabel: false)
      ]),
      '''
switch (null) {
  case 0:
}''',
      limited: '''
switch (null) { case 0: }''');

  testStatement(
      new SwitchStatement(expression, [
        new SwitchCaseImpl([], [0], emptyBlock,
            hasLabel: false, isDefault: true)
      ]),
      '''
switch (null) {
  default:
}''',
      limited: '''
switch (null) { default: }''');

  testStatement(
      new SwitchStatement(expression, [
        new SwitchCaseImpl([case0, case1], [0, 1], returnBlock1,
            hasLabel: false),
        new SwitchCaseImpl([case2], [0], returnBlock2,
            hasLabel: true, isDefault: true)
      ]),
      '''
switch (null) {
  case 0:
  case 1:
    return;
  case 2:
  default:
    return;
}''',
      limited: '''
switch (null) { case 0: case 1: return; case 2: default: return; }''');
}

void _testBreakStatementImpl() {
  WhileStatement whileStatement =
      new WhileStatement(new BoolLiteral(true), new Block([]));
  LabeledStatement labeledStatement = new LabeledStatement(whileStatement);
  testStatement(
      new BreakStatementImpl(isContinue: false)
        ..target = labeledStatement
        ..targetStatement = whileStatement,
      '''
break label0;''');
  testStatement(
      new BreakStatementImpl(isContinue: true)
        ..target = labeledStatement
        ..targetStatement = whileStatement,
      '''
continue label0;''');
}

void _testCascade() {
  VariableDeclaration variable =
      new VariableDeclaration.forValue(new IntLiteral(0));
  Cascade cascade = new Cascade(variable, isNullAware: false);
  testExpression(cascade, '''
let final dynamic #0 = 0 in cascade {} => #0''');

  cascade.addCascadeExpression(new DynamicSet(DynamicAccessKind.Dynamic,
      new VariableGet(variable), new Name('foo'), new IntLiteral(1)));
  testExpression(cascade, '''
let final dynamic #0 = 0 in cascade {
  #0.foo = 1;
} => #0''', limited: '''
let final dynamic #0 = 0 in cascade { #0.foo = 1; } => #0''');

  cascade.addCascadeExpression(new DynamicSet(DynamicAccessKind.Dynamic,
      new VariableGet(variable), new Name('bar'), new IntLiteral(2)));
  testExpression(cascade, '''
let final dynamic #0 = 0 in cascade {
  #0.foo = 1;
  #0.bar = 2;
} => #0''', limited: '''
let final dynamic #0 = 0 in cascade { #0.foo = 1; #0.bar = 2; } => #0''');
}

void _testDeferredCheck() {
  Library library = new Library(dummyUri, fileUri: dummyUri);
  LibraryDependency dependency =
      LibraryDependency.deferredImport(library, 'pre');
  VariableDeclaration check =
      new VariableDeclaration.forValue(new CheckLibraryIsLoaded(dependency));
  testExpression(new DeferredCheck(check, new IntLiteral(0)), '''
let final dynamic #0 = pre.checkLibraryIsLoaded() in 0''');
}

void _testFactoryConstructorInvocationJudgment() {
  Library library = new Library(dummyUri, fileUri: dummyUri);
  Class cls = new Class(name: 'Class', fileUri: dummyUri);
  library.addClass(cls);
  Procedure factoryConstructor = new Procedure(
      new Name(''), ProcedureKind.Factory, new FunctionNode(null),
      fileUri: dummyUri);
  cls.addProcedure(factoryConstructor);

  testExpression(
      new FactoryConstructorInvocation(
          factoryConstructor, new ArgumentsImpl([])),
      '''
new Class()''',
      verbose: '''
new library test:dummy::Class()''');

  testExpression(
      new FactoryConstructorInvocation(
          factoryConstructor,
          new ArgumentsImpl([new IntLiteral(0)],
              types: [const VoidType()],
              named: [new NamedExpression('bar', new IntLiteral(1))])),
      '''
new Class<void>(0, bar: 1)''',
      verbose: '''
new library test:dummy::Class<void>(0, bar: 1)''');

  factoryConstructor.name = new Name('foo');
  testExpression(
      new FactoryConstructorInvocation(
          factoryConstructor,
          new ArgumentsImpl([new IntLiteral(0)],
              types: [const VoidType()],
              named: [new NamedExpression('bar', new IntLiteral(1))])),
      '''
new Class<void>.foo(0, bar: 1)''',
      verbose: '''
new library test:dummy::Class<void>.foo(0, bar: 1)''');
}

void _testTypeAliasedConstructorInvocation() {
  DillTarget dillTarget = new DillTarget(
      new Ticker(),
      new UriTranslator(
          new TargetLibrariesSpecification('dummy'), new PackageConfig([])),
      new NoneTarget(new TargetFlags()));
  DillLoader dillLoader = new DillLoader(dillTarget);
  Library library = new Library(dummyUri, fileUri: dummyUri);
  Class cls = new Class(name: 'Class', fileUri: dummyUri);
  library.addClass(cls);
  Constructor constructor = new Constructor(new FunctionNode(null),
      name: new Name(''), fileUri: dummyUri);
  cls.addConstructor(constructor);
  DillLibraryBuilder libraryBuilder =
      new DillLibraryBuilder(library, dillLoader);
  Typedef typedef = new Typedef(
      'Typedef', new InterfaceType(cls, Nullability.nonNullable),
      fileUri: dummyUri);
  library.addTypedef(typedef);
  TypeAliasBuilder typeAliasBuilder =
      new DillTypeAliasBuilder(typedef, null, libraryBuilder);

  testExpression(
      new TypeAliasedConstructorInvocation(
          typeAliasBuilder, constructor, new ArgumentsImpl([])),
      '''
new Typedef()''',
      verbose: '''
new library test:dummy::Typedef()''');

  testExpression(
      new TypeAliasedConstructorInvocation(
          typeAliasBuilder,
          constructor,
          new ArgumentsImpl([new IntLiteral(0)],
              types: [const VoidType()],
              named: [new NamedExpression('bar', new IntLiteral(1))])),
      '''
new Typedef<void>(0, bar: 1)''',
      verbose: '''
new library test:dummy::Typedef<void>(0, bar: 1)''');

  constructor.name = new Name('foo');
  testExpression(
      new TypeAliasedConstructorInvocation(
          typeAliasBuilder,
          constructor,
          new ArgumentsImpl([new IntLiteral(0)],
              types: [const VoidType()],
              named: [new NamedExpression('bar', new IntLiteral(1))])),
      '''
new Typedef<void>.foo(0, bar: 1)''',
      verbose: '''
new library test:dummy::Typedef<void>.foo(0, bar: 1)''');

  constructor.name = new Name('foo');
  testExpression(
      new TypeAliasedConstructorInvocation(
          typeAliasBuilder,
          constructor,
          new ArgumentsImpl([new IntLiteral(0)],
              types: [const VoidType()],
              named: [new NamedExpression('bar', new IntLiteral(1))]),
          isConst: true),
      '''
const Typedef<void>.foo(0, bar: 1)''',
      verbose: '''
const library test:dummy::Typedef<void>.foo(0, bar: 1)''');
}

void _testTypeAliasedFactoryInvocation() {
  DillTarget dillTarget = new DillTarget(
      new Ticker(),
      new UriTranslator(
          new TargetLibrariesSpecification('dummy'), new PackageConfig([])),
      new NoneTarget(new TargetFlags()));
  DillLoader dillLoader = new DillLoader(dillTarget);
  Library library = new Library(dummyUri, fileUri: dummyUri);
  Class cls = new Class(name: 'Class', fileUri: dummyUri);
  library.addClass(cls);
  Procedure factoryConstructor = new Procedure(
      new Name(''), ProcedureKind.Factory, new FunctionNode(null),
      fileUri: dummyUri);
  cls.addProcedure(factoryConstructor);
  DillLibraryBuilder libraryBuilder =
      new DillLibraryBuilder(library, dillLoader);
  Typedef typedef = new Typedef(
      'Typedef', new InterfaceType(cls, Nullability.nonNullable),
      fileUri: dummyUri);
  library.addTypedef(typedef);
  TypeAliasBuilder typeAliasBuilder =
      new DillTypeAliasBuilder(typedef, null, libraryBuilder);

  testExpression(
      new TypeAliasedFactoryInvocation(
          typeAliasBuilder, factoryConstructor, new ArgumentsImpl([])),
      '''
new Typedef()''',
      verbose: '''
new library test:dummy::Typedef()''');

  testExpression(
      new TypeAliasedFactoryInvocation(
          typeAliasBuilder,
          factoryConstructor,
          new ArgumentsImpl([new IntLiteral(0)],
              types: [const VoidType()],
              named: [new NamedExpression('bar', new IntLiteral(1))])),
      '''
new Typedef<void>(0, bar: 1)''',
      verbose: '''
new library test:dummy::Typedef<void>(0, bar: 1)''');

  factoryConstructor.name = new Name('foo');
  testExpression(
      new TypeAliasedFactoryInvocation(
          typeAliasBuilder,
          factoryConstructor,
          new ArgumentsImpl([new IntLiteral(0)],
              types: [const VoidType()],
              named: [new NamedExpression('bar', new IntLiteral(1))])),
      '''
new Typedef<void>.foo(0, bar: 1)''',
      verbose: '''
new library test:dummy::Typedef<void>.foo(0, bar: 1)''');

  factoryConstructor.name = new Name('foo');
  testExpression(
      new TypeAliasedFactoryInvocation(
          typeAliasBuilder,
          factoryConstructor,
          new ArgumentsImpl([new IntLiteral(0)],
              types: [const VoidType()],
              named: [new NamedExpression('bar', new IntLiteral(1))]),
          isConst: true),
      '''
const Typedef<void>.foo(0, bar: 1)''',
      verbose: '''
const library test:dummy::Typedef<void>.foo(0, bar: 1)''');
}

void _testFunctionDeclarationImpl() {
  testStatement(
      new FunctionDeclarationImpl(new VariableDeclarationImpl('foo', 0),
          new FunctionNode(new Block([]))),
      '''
dynamic foo() {}''');
}

void _testIfNullExpression() {
  testExpression(new IfNullExpression(new IntLiteral(0), new IntLiteral(1)), '''
0 ?? 1''');
}

void _testIntLiterals() {
  testExpression(new IntJudgment(0, null), '0');
  testExpression(new IntJudgment(0, 'foo'), 'foo');
  testExpression(new ShadowLargeIntLiteral('bar', TreeNode.noOffset), 'bar');
}

void _testInternalMethodInvocation() {
  testExpression(
      new MethodInvocation(
          new IntLiteral(0), new Name('boz'), new ArgumentsImpl([])),
      '''
0.boz()''');
  testExpression(
      new MethodInvocation(
          new IntLiteral(0),
          new Name('boz'),
          new ArgumentsImpl([
            new IntLiteral(1)
          ], types: [
            const VoidType(),
            const DynamicType()
          ], named: [
            new NamedExpression('foo', new IntLiteral(2)),
            new NamedExpression('bar', new IntLiteral(3))
          ])),
      '''
0.boz<void, dynamic>(1, foo: 2, bar: 3)''');
}

void _testInternalPropertyGet() {
  testExpression(new PropertyGet(new IntLiteral(0), new Name('boz')), '''
0.boz''');
}

void _testInternalPropertySet() {
  testExpression(
      new PropertySet(new IntLiteral(0), new Name('boz'), new IntLiteral(1),
          forEffect: false, readOnlyReceiver: false),
      '''
0.boz = 1''');
}

void _testExpressionInvocation() {
  testExpression(
      new ExpressionInvocation(new IntLiteral(0), new ArgumentsImpl([])), '''
0()''');
  testExpression(
      new ExpressionInvocation(
          new IntLiteral(0),
          new ArgumentsImpl([
            new IntLiteral(1)
          ], types: [
            const VoidType(),
            const DynamicType()
          ], named: [
            new NamedExpression('foo', new IntLiteral(2)),
            new NamedExpression('bar', new IntLiteral(3))
          ])),
      '''
0<void, dynamic>(1, foo: 2, bar: 3)''');
}

void _testNamedFunctionExpressionJudgment() {
  testExpression(
      new NamedFunctionExpressionJudgment(new VariableDeclarationImpl('foo', 0,
          initializer:
              new FunctionExpression(new FunctionNode(new Block([]))))),
      '''
let dynamic foo = dynamic () {} in foo''');
}

void _testNullAwareMethodInvocation() {
  VariableDeclarationImpl variable =
      new VariableDeclarationImpl.forValue(new IntLiteral(0));

  // The usual use of this node.
  testExpression(
      new NullAwareMethodInvocation(
          variable,
          new DynamicInvocation(
              DynamicAccessKind.Dynamic,
              new VariableGet(variable),
              new Name('foo'),
              new ArgumentsImpl([]))),
      '''
0?.foo()''');

  // TODO(johnniwinther): Add a test using InstanceInvocation instead of
  // DynamicInvocation.

  // An unusual use of this node.
  testExpression(
      new NullAwareMethodInvocation(variable,
          new PropertyGet(new VariableGet(variable), new Name('foo'))),
      '''
let final dynamic #0 = 0 in null-aware #0.foo''');
}

void _testNullAwarePropertyGet() {
  VariableDeclarationImpl variable =
      new VariableDeclarationImpl.forValue(new IntLiteral(0));

  // The usual use of this node.
  testExpression(
      new NullAwarePropertyGet(variable,
          new PropertyGet(new VariableGet(variable), new Name('foo'))),
      '''
0?.foo''');

  // An unusual use of this node.
  testExpression(
      new NullAwarePropertyGet(
          variable,
          new DynamicInvocation(
              DynamicAccessKind.Dynamic,
              new VariableGet(variable),
              new Name('foo'),
              new ArgumentsImpl([]))),
      '''
let final dynamic #0 = 0 in null-aware #0.foo()''');
}

void _testNullAwarePropertySet() {
  VariableDeclarationImpl variable =
      new VariableDeclarationImpl.forValue(new IntLiteral(0));

  testExpression(
      new NullAwarePropertySet(
          variable,
          new DynamicSet(DynamicAccessKind.Dynamic, new VariableGet(variable),
              new Name('foo'), new IntLiteral(1))),
      '''
0?.foo = 1''');

  // TODO(johnniwinther): Add a test using InstanceSet instead of DynamicSet.

  testExpression(
      new NullAwarePropertySet(
          variable,
          new DynamicInvocation(
              DynamicAccessKind.Dynamic,
              new VariableGet(variable),
              new Name('foo'),
              new ArgumentsImpl([]))),
      '''
let final dynamic #0 = 0 in null-aware #0.foo()''');
}

void _testReturnStatementImpl() {
  testStatement(new ReturnStatementImpl(false), '''
return;''');
  testStatement(new ReturnStatementImpl(true), '''
=>;''');
  testStatement(new ReturnStatementImpl(false, new IntLiteral(0)), '''
return 0;''');
  testStatement(new ReturnStatementImpl(true, new IntLiteral(0)), '''
=> 0;''');
}

void _testVariableDeclarationImpl() {
  testStatement(new VariableDeclarationImpl('foo', 0), '''
dynamic foo;''');
  testStatement(
      new VariableDeclarationImpl('foo', 0, initializer: new IntLiteral(0)), '''
dynamic foo = 0;''');
  testStatement(
      new VariableDeclarationImpl('foo', 0,
          type: const VoidType(),
          initializer: new IntLiteral(0),
          isFinal: true,
          isRequired: true),
      '''
required final void foo;''');
  testStatement(
      new VariableDeclarationImpl('foo', 0,
          type: const VoidType(), initializer: new IntLiteral(0), isLate: true),
      '''
late void foo = 0;''');
  testStatement(
      new VariableDeclarationImpl('foo', 0,
          type: const VoidType(), initializer: new IntLiteral(0))
        ..lateGetter = new VariableDeclarationImpl('foo#getter', 0),
      '''
late void foo = 0;''');
  testStatement(
      new VariableDeclarationImpl('foo', 0,
          type: const VoidType(), initializer: new IntLiteral(0))
        ..lateGetter = new VariableDeclarationImpl('foo#getter', 0)
        ..lateType = const DynamicType(),
      '''
late dynamic foo = 0;''');
}

void _testVariableGetImpl() {
  VariableDeclaration variable = new VariableDeclaration('foo');
  testExpression(new VariableGetImpl(variable, forNullGuardedAccess: false), '''
foo''');
  testExpression(new VariableGetImpl(variable, forNullGuardedAccess: true), '''
foo''');
  testExpression(
      new VariableGetImpl(variable, forNullGuardedAccess: false)
        ..promotedType = const VoidType(),
      '''
foo{void}''');
}

void _testLoadLibraryImpl() {
  Library library = new Library(dummyUri, fileUri: dummyUri);
  LibraryDependency dependency =
      LibraryDependency.deferredImport(library, 'pre');
  testExpression(new LoadLibraryImpl(dependency, new ArgumentsImpl([])), '''
pre.loadLibrary()''');
  testExpression(
      new LoadLibraryImpl(dependency, new ArgumentsImpl([new IntLiteral(0)])),
      '''
pre.loadLibrary(0)''');
}

void _testLoadLibraryTearOff() {
  Library library = new Library(dummyUri, fileUri: dummyUri);
  LibraryDependency dependency =
      LibraryDependency.deferredImport(library, 'pre');
  Procedure procedure = new Procedure(new Name('get#loadLibrary'),
      ProcedureKind.Getter, new FunctionNode(new Block([])),
      fileUri: dummyUri);
  testExpression(new LoadLibraryTearOff(dependency, procedure), ''' 
pre.loadLibrary''');
}

void _testIfNullPropertySet() {
  testExpression(
      new IfNullPropertySet(
          new IntLiteral(0), new Name('foo'), new IntLiteral(1),
          readOffset: -1, writeOffset: -1, forEffect: false),
      '0.foo ??= 1');

  testExpression(
      new IfNullPropertySet(
          new IntLiteral(0), new Name('foo'), new IntLiteral(1),
          readOffset: -1, writeOffset: -1, forEffect: true),
      '0.foo ??= 1');
}

void _testIfNullSet() {
  VariableDeclaration variable = new VariableDeclaration('foo');
  testExpression(
      new IfNullSet(new VariableGet(variable),
          new VariableSet(variable, new IntLiteral(1)),
          forEffect: false),
      '''
foo ?? foo = 1''');

  testExpression(
      new IfNullSet(new VariableGet(variable),
          new VariableSet(variable, new IntLiteral(1)),
          forEffect: true),
      '''
foo ?? foo = 1''');
}

void _testCompoundExtensionSet() {}

void _testCompoundPropertySet() {
  testExpression(
      new CompoundPropertySet(
          new IntLiteral(0), new Name('foo'), new Name('+'), new IntLiteral(1),
          readOffset: TreeNode.noOffset,
          binaryOffset: TreeNode.noOffset,
          writeOffset: TreeNode.noOffset,
          forEffect: false),
      '''
0.foo += 1''');
}

void _testPropertyPostIncDec() {}

void _testLocalPostIncDec() {}

void _testStaticPostIncDec() {}

void _testSuperPostIncDec() {}

void _testIndexGet() {
  testExpression(new IndexGet(new IntLiteral(0), new IntLiteral(1)), '''
0[1]''');
}

void _testIndexSet() {
  testExpression(
      new IndexSet(new IntLiteral(0), new IntLiteral(1), new IntLiteral(2),
          forEffect: false),
      '''
0[1] = 2''');
}

void _testSuperIndexSet() {}

void _testExtensionIndexSet() {
  Library library = new Library(dummyUri, fileUri: dummyUri);
  Extension extension = new Extension(
      name: 'Extension',
      typeParameters: [new TypeParameter('T')],
      fileUri: dummyUri);
  library.addExtension(extension);
  Procedure setter = new Procedure(
      new Name(''), ProcedureKind.Method, new FunctionNode(null),
      fileUri: dummyUri);
  library.addProcedure(setter);

  testExpression(
      new ExtensionIndexSet(extension, null, new IntLiteral(0), setter,
          new IntLiteral(1), new IntLiteral(2)),
      '''
Extension(0)[1] = 2''');

  testExpression(
      new ExtensionIndexSet(extension, [const VoidType()], new IntLiteral(0),
          setter, new IntLiteral(1), new IntLiteral(2)),
      '''
Extension<void>(0)[1] = 2''');
}

void _testIfNullIndexSet() {}

void _testIfNullSuperIndexSet() {}

void _testIfNullExtensionIndexSet() {}

void _testCompoundIndexSet() {
  testExpression(
      new CompoundIndexSet(new IntLiteral(0), new IntLiteral(1), new Name('+'),
          new IntLiteral(2),
          readOffset: -1,
          binaryOffset: -1,
          writeOffset: -1,
          forEffect: false,
          forPostIncDec: false),
      '''
0[1] += 2''');
  testExpression(
      new CompoundIndexSet(new IntLiteral(0), new IntLiteral(1), new Name('+'),
          new IntLiteral(1),
          readOffset: -1,
          binaryOffset: -1,
          writeOffset: -1,
          forEffect: false,
          forPostIncDec: true),
      '''
0[1]++''');
  testExpression(
      new CompoundIndexSet(new IntLiteral(0), new IntLiteral(1), new Name('-'),
          new IntLiteral(1),
          readOffset: -1,
          binaryOffset: -1,
          writeOffset: -1,
          forEffect: false,
          forPostIncDec: true),
      '''
0[1]--''');
  testExpression(
      new CompoundIndexSet(new IntLiteral(0), new IntLiteral(1), new Name('*'),
          new IntLiteral(1),
          readOffset: -1,
          binaryOffset: -1,
          writeOffset: -1,
          forEffect: false,
          forPostIncDec: true),
      '''
0[1] *= 1''');
  testExpression(
      new CompoundIndexSet(new IntLiteral(0), new IntLiteral(1), new Name('+'),
          new IntLiteral(2),
          readOffset: -1,
          binaryOffset: -1,
          writeOffset: -1,
          forEffect: false,
          forPostIncDec: true),
      '''
0[1] += 2''');
}

void _testNullAwareCompoundSet() {
  testExpression(
      new NullAwareCompoundSet(
          new IntLiteral(0), new Name('foo'), new Name('+'), new IntLiteral(1),
          readOffset: TreeNode.noOffset,
          binaryOffset: TreeNode.noOffset,
          writeOffset: TreeNode.noOffset,
          forPostIncDec: false,
          forEffect: false),
      '''
0?.foo += 1''');
  testExpression(
      new NullAwareCompoundSet(
          new IntLiteral(0), new Name('foo'), new Name('+'), new IntLiteral(1),
          readOffset: TreeNode.noOffset,
          binaryOffset: TreeNode.noOffset,
          writeOffset: TreeNode.noOffset,
          forPostIncDec: true,
          forEffect: false),
      '''
0?.foo++''');
}

void _testNullAwareIfNullSet() {
  testExpression(
      new NullAwareIfNullSet(
          new IntLiteral(0), new Name('foo'), new IntLiteral(1),
          readOffset: TreeNode.noOffset,
          testOffset: TreeNode.noOffset,
          writeOffset: TreeNode.noOffset,
          forEffect: false),
      '''
0?.foo ??= 1''');
}

void _testCompoundSuperIndexSet() {}

void _testCompoundExtensionIndexSet() {}

void _testExtensionSet() {}

void _testNullAwareExtension() {}

void _testPropertySetImpl() {}

void _testExtensionTearOff() {}

void _testEqualsExpression() {
  testExpression(
      new EqualsExpression(new IntLiteral(0), new IntLiteral(1), isNot: false),
      '''
0 == 1''');
  testExpression(
      new EqualsExpression(new IntLiteral(0), new IntLiteral(1), isNot: true),
      '''
0 != 1''');
}

void _testBinaryExpression() {
  testExpression(
      new BinaryExpression(new IntLiteral(0), new Name('+'), new IntLiteral(1)),
      '''
0 + 1''');
  testExpression(
      new BinaryExpression(
          new BinaryExpression(
              new IntLiteral(0), new Name('-'), new IntLiteral(1)),
          new Name('+'),
          new BinaryExpression(
              new IntLiteral(2), new Name('-'), new IntLiteral(3))),
      '''
0 - 1 + 2 - 3''');
  testExpression(
      new BinaryExpression(
          new BinaryExpression(
              new IntLiteral(0), new Name('*'), new IntLiteral(1)),
          new Name('+'),
          new BinaryExpression(
              new IntLiteral(2), new Name('/'), new IntLiteral(3))),
      '''
0 * 1 + 2 / 3''');
  testExpression(
      new BinaryExpression(
          new BinaryExpression(
              new IntLiteral(0), new Name('+'), new IntLiteral(1)),
          new Name('*'),
          new BinaryExpression(
              new IntLiteral(2), new Name('-'), new IntLiteral(3))),
      '''
(0 + 1) * (2 - 3)''');
}

void _testUnaryExpression() {
  testExpression(new UnaryExpression(new Name('unary-'), new IntLiteral(0)), '''
-0''');
  testExpression(new UnaryExpression(new Name('~'), new IntLiteral(0)), '''
~0''');

  testExpression(
      new UnaryExpression(
          new Name('unary-'),
          new BinaryExpression(
              new IntLiteral(0), new Name('+'), new IntLiteral(1))),
      '''
-(0 + 1)''');
}

void _testParenthesizedExpression() {
  testExpression(new ParenthesizedExpression(new IntLiteral(0)), '''
(0)''');
}

void _testSpreadElement() {
  testExpression(new SpreadElement(new IntLiteral(0), isNullAware: false), '''
...0''');
  testExpression(new SpreadElement(new IntLiteral(0), isNullAware: true), '''
...?0''');
}

void _testIfElement() {
  testExpression(new IfElement(new IntLiteral(0), new IntLiteral(1), null), '''
if (0) 1''');
  testExpression(
      new IfElement(new IntLiteral(0), new IntLiteral(1), new IntLiteral(2)),
      '''
if (0) 1 else 2''');
}

void _testForElement() {}

void _testForInElement() {}

void _testSpreadMapEntry() {}

void _testIfMapEntry() {}

void _testForMapEntry() {}

void _testForInMapEntry() {}