pkg/front_end/test/generator_to_string_test.dart

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

/// Test of toString on generators.

import 'package:_fe_analyzer_shared/src/scanner/scanner.dart'
    show Token, scanString;
import 'package:expect/expect.dart' show Expect;
import 'package:front_end/src/base/compiler_context.dart' show CompilerContext;
import 'package:front_end/src/base/local_scope.dart';
import 'package:front_end/src/base/name_space.dart';
import 'package:front_end/src/base/scope.dart';
import 'package:front_end/src/base/uri_translator.dart';
import 'package:front_end/src/builder/compilation_unit.dart';
import 'package:front_end/src/builder/declaration_builders.dart';
import 'package:front_end/src/builder/prefix_builder.dart';
import 'package:front_end/src/builder/type_builder.dart';
import 'package:front_end/src/codes/cfe_codes.dart'
    show Message, codeUnspecified;
import 'package:front_end/src/dill/dill_target.dart' show DillTarget;
import 'package:front_end/src/dill/dill_type_parameter_builder.dart';
import 'package:front_end/src/kernel/body_builder.dart' show BodyBuilder;
import 'package:front_end/src/kernel/body_builder_context.dart';
import 'package:front_end/src/kernel/expression_generator.dart';
import 'package:front_end/src/kernel/expression_generator_helper.dart';
import 'package:front_end/src/kernel/kernel_target.dart' show KernelTarget;
import 'package:front_end/src/kernel/load_library_builder.dart';
import 'package:front_end/src/source/name_space_builder.dart';
import 'package:front_end/src/source/source_compilation_unit.dart'
    show SourceCompilationUnitImpl;
import 'package:front_end/src/source/source_library_builder.dart'
    show ImplicitLanguageVersion, SourceLibraryBuilder;
import 'package:front_end/src/source/source_loader.dart';
import 'package:front_end/src/type_inference/type_inference_engine.dart';
import 'package:kernel/ast.dart'
    show
        Arguments,
        Class,
        Component,
        DynamicType,
        Expression,
        FunctionNode,
        Library,
        Name,
        Procedure,
        ProcedureKind,
        StringLiteral,
        TypeParameter,
        VariableDeclaration,
        VariableGet,
        defaultLanguageVersion;
import 'package:kernel/class_hierarchy.dart';
import 'package:kernel/core_types.dart';
import 'package:kernel/target/targets.dart' show NoneTarget, TargetFlags;

import 'mock_file_system.dart';

void check(String expected, Object generator) {
  Expect.stringEquals(expected, "$generator");
}

Future<void> main() async {
  await CompilerContext.runWithDefaultOptions((CompilerContext c) async {
    await c.options.validateOptions(errorOnMissingInput: false);

    Token token = scanString("    myToken").tokens;
    Uri uri = Uri.parse("org-dartlang-test:my_library.dart");

    /// Create dummy variants of Component, CoreTypes and ClassHierarchy for
    /// the BodyBuilder. These are not actually used in the test.
    Component component = new Component();
    CoreTypes coreTypes = new CoreTypes(component);
    ClassHierarchy hierarchy = new ClassHierarchy(component, coreTypes);

    Arguments arguments = new Arguments(<Expression>[new StringLiteral("arg")]);
    Expression expression =
        new VariableGet(new VariableDeclaration("expression"));
    Expression index = new VariableGet(new VariableDeclaration("index"));
    UriTranslator uriTranslator = await c.options.getUriTranslator();
    SourceLoader loader = new KernelTarget(
            c,
            const MockFileSystem(),
            false,
            new DillTarget(c, c.options.ticker, uriTranslator,
                new NoneTarget(new TargetFlags())),
            uriTranslator)
        .loader;
    SourceCompilationUnit compilationUnit = new SourceCompilationUnitImpl(
        importUri: uri,
        fileUri: uri,
        packageUri: null,
        packageLanguageVersion:
            new ImplicitLanguageVersion(defaultLanguageVersion),
        originImportUri: uri,
        indexedLibrary: null,
        forAugmentationLibrary: false,
        augmentationRoot: null,
        resolveInLibrary: null,
        referenceIsPartOwner: null,
        forPatchLibrary: false,
        isAugmenting: false,
        isUnsupported: false,
        loader: loader,
        mayImplementRestrictedTypes: false);
    SourceLibraryBuilder libraryBuilder = new SourceLibraryBuilder(
        compilationUnit: compilationUnit,
        packageUri: null,
        importUri: uri,
        fileUri: uri,
        originImportUri: uri,
        packageLanguageVersion:
            new ImplicitLanguageVersion(defaultLanguageVersion),
        loader: loader,
        isUnsupported: false,
        isAugmentation: false,
        isPatch: false,
        importNameSpace: new ComputedMutableNameSpace(),
        libraryNameSpaceBuilder: new LibraryNameSpaceBuilder());
    libraryBuilder.compilationUnit.markLanguageVersionFinal();
    LoadLibraryBuilder loadLibraryBuilder = new LoadLibraryBuilder(
        libraryBuilder,
        /*dummyLibraryDependency,*/ -1,
        libraryBuilder.compilationUnit,
        'prefix',
        -1,
        null);
    Procedure getter = new Procedure(
        new Name("myGetter"), ProcedureKind.Getter, new FunctionNode(null),
        fileUri: uri);
    Procedure interfaceTarget = new Procedure(new Name("myInterfaceTarget"),
        ProcedureKind.Method, new FunctionNode(null),
        fileUri: uri);
    Procedure setter = new Procedure(
        new Name("mySetter"), ProcedureKind.Setter, new FunctionNode(null),
        fileUri: uri);
    Message message = codeUnspecified.withArguments("My Message.");
    Name binaryOperator = new Name("+");
    Name name = new Name("bar");
    PrefixBuilder prefixBuilder = new PrefixBuilder(
        "myPrefix", false, libraryBuilder, null,
        fileUri: uri, prefixOffset: -1, importOffset: -1);
    String assignmentOperator = "+=";
    TypeDeclarationBuilder declaration = new DillNominalParameterBuilder(
        new TypeParameter("T", const DynamicType(), const DynamicType()),
        loader: null);
    VariableDeclaration variable =
        new VariableDeclaration(null, isSynthesized: true);

    TypeInferenceEngineImpl engine = new TypeInferenceEngineImpl(null, null);
    engine.prepareTopLevel(coreTypes, hierarchy);

    BodyBuilder helper = new BodyBuilder(
        libraryBuilder: libraryBuilder,
        context: new LibraryBodyBuilderContext(libraryBuilder),
        uri: uri,
        enclosingScope:
            new FixedLocalScope(kind: ScopeKind.library, debugName: "dummy"),
        coreTypes: coreTypes,
        hierarchy: hierarchy,
        typeInferrer: engine.createTopLevelTypeInferrer(uri, null,
            libraryBuilder, compilationUnit.compilationUnitScope, null));

    Generator generator =
        new ThisAccessGenerator(helper, token, false, false, false);

    Library library = new Library(uri, fileUri: uri);
    Class cls = new Class(name: 'foo', fileUri: uri);
    library.addClass(cls);
    library.addProcedure(getter);
    library.addProcedure(setter);
    cls.addProcedure(interfaceTarget);

    PrefixUseGenerator prefixUseGenerator =
        new PrefixUseGenerator(helper, token, prefixBuilder);

    check(
        "DelayedAssignment(offset: 4, value: expression,"
        " assignmentOperator: +=)",
        new DelayedAssignment(
            helper, token, generator, expression, assignmentOperator));
    check("DelayedPostfixIncrement(offset: 4, binaryOperator: +)",
        new DelayedPostfixIncrement(helper, token, generator, binaryOperator));
    check("VariableUseGenerator(offset: 4, variable: dynamic #t1;\n)",
        new VariableUseGenerator(helper, token, variable));
    check(
        "PropertyAccessGenerator(offset: 4,"
        " receiver: expression, name: bar)",
        new PropertyAccessGenerator(helper, token, expression, name));
    check("ThisPropertyAccessGenerator(offset: 4, name: bar)",
        new ThisPropertyAccessGenerator(helper, token, name));
    check(
        "NullAwarePropertyAccessGenerator(offset: 4,"
        " receiver: expression, name: bar)",
        new NullAwarePropertyAccessGenerator(helper, token, expression, name));
    check(
        "SuperPropertyAccessGenerator(offset: 4, name: bar,"
        " getter: $uri::myGetter, setter: $uri::mySetter)",
        new SuperPropertyAccessGenerator(helper, token, name, getter, setter));
    check(
        "IndexedAccessGenerator(offset: 4, receiver: expression, index: index,"
        " isNullAware: false)",
        new IndexedAccessGenerator(helper, token, expression, index,
            isNullAware: false));
    check("ThisIndexedAccessGenerator(offset: 4, index: index)",
        new ThisIndexedAccessGenerator(helper, token, index));
    check(
        "SuperIndexedAccessGenerator(offset: 4, index: index,"
        " getter: $uri::myGetter, setter: $uri::mySetter)",
        new SuperIndexedAccessGenerator(helper, token, index, getter, setter));
    check(
        "StaticAccessGenerator(offset: 4, targetName: foo,"
        " readTarget: $uri::myGetter,"
        " writeTarget: $uri::mySetter)",
        new StaticAccessGenerator(
            helper, token, new Name('foo'), getter, null, setter));
    check(
        "LoadLibraryGenerator(offset: 4,"
        " builder: Instance of 'LoadLibraryBuilder')",
        new LoadLibraryGenerator(helper, token, loadLibraryBuilder));
    check(
        "ThisAccessGenerator(offset: 4, isInitializer: false, "
        "inFieldInitializer: false, inLateFieldInitializer: false, "
        "isSuper: false)",
        new ThisAccessGenerator(helper, token, false, false, false));
    check("IncompleteErrorGenerator(offset: 4, message: Unspecified)",
        new IncompleteErrorGenerator(helper, token, message));
    check("InvocationSelector(offset: 4, name: bar, arguments: (\"arg\"))",
        new InvocationSelector(helper, token, name, null, arguments));
    check("PropertySelector(offset: 4, name: bar)",
        new PropertySelector(helper, token, name));
    check(
        "DeferredAccessGenerator(offset: 4,"
        " prefixGenerator: PrefixUseGenerator("
        "offset: 4, prefix: myPrefix, deferred: false),"
        " suffixGenerator: ThisAccessGenerator(offset: 4, isInitializer: false,"
        " inFieldInitializer: false, inLateFieldInitializer: false,"
        " isSuper: false))",
        new DeferredAccessGenerator(
            helper, token, prefixUseGenerator, generator));
    check(
        "ReadOnlyAccessGenerator(offset: 4, expression: expression,"
        " plainNameForRead: foo, kind: ReadOnlyAccessKind.FinalVariable)",
        new ReadOnlyAccessGenerator(helper, token, expression, "foo",
            ReadOnlyAccessKind.FinalVariable));
    check(
        "ParenthesizedExpressionGenerator(offset: 4, expression: expression,"
        " plainNameForRead: , kind:"
        " ReadOnlyAccessKind.ParenthesizedExpression)",
        new ParenthesizedExpressionGenerator(helper, token, expression));
    check(
        "TypeUseGenerator(offset: 4, "
        "declaration: DillNominalParameterBuilder(T), "
        "plainNameForRead: foo)",
        new TypeUseGenerator(
            helper, token, declaration, new SyntheticTypeName("foo", -1)));
    check(
        "UnresolvedNameGenerator(offset: 4, name: bar)",
        new UnresolvedNameGenerator.internal(
            helper, token, name, UnresolvedKind.Unknown));
    check("PrefixUseGenerator(offset: 4, prefix: myPrefix, deferred: false)",
        prefixUseGenerator);
    check(
        "UnexpectedQualifiedUseGenerator("
        "offset: 4, prefixGenerator: , isInitializer: false,"
        " inFieldInitializer: false, inLateFieldInitializer: false,"
        " isSuper: false)",
        new UnexpectedQualifiedUseGenerator(helper, token, generator,
            errorHasBeenReported: false));
    return Future<void>.value();
  });
}