Johnni Winther
d56cabaf1f
This remove the iterators from the NameSpace interface and instead collects the list of builders belonging to a library or declaration directly inside these builders. Adds ComputedNameSpace for import, export and prefix name spaces. This allows for replacing a member and has a filteredIterator function. These name spaces are computed from import/exports and therefore need to be iterated through directly and replace builder when two builders collide. Change-Id: Iec974656c5331498aa1cfca7973300ac6e044994 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/428820 Commit-Queue: Johnni Winther <johnniwinther@google.com> Reviewed-by: Chloe Stefantsova <cstefantsova@google.com>
273 lines
12 KiB
Dart
273 lines
12 KiB
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/declaration_builders.dart';
|
|
import 'package:front_end/src/builder/library_builder.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, templateUnspecified;
|
|
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/source_library_builder.dart'
|
|
show
|
|
ImplicitLanguageVersion,
|
|
SourceCompilationUnitImpl,
|
|
SourceLibraryBuilder;
|
|
import 'package:front_end/src/source/source_loader.dart';
|
|
import 'package:front_end/src/source/type_parameter_scope_builder.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 = templateUnspecified.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: final dynamic #t1 = expression;\n,"
|
|
" receiverExpression: 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, '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, false));
|
|
return Future<void>.value();
|
|
});
|
|
}
|