| // 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. |
| |
| library fasta.source_library_builder; |
| |
| import 'dart:convert' show jsonEncode; |
| |
| import 'package:_fe_analyzer_shared/src/messages/severity.dart' show Severity; |
| |
| import 'package:_fe_analyzer_shared/src/scanner/token.dart' show Token; |
| |
| import 'package:_fe_analyzer_shared/src/util/resolve_relative_uri.dart' |
| show resolveRelativeUri; |
| |
| import 'package:kernel/ast.dart' |
| show |
| Arguments, |
| AsyncMarker, |
| Class, |
| Constructor, |
| ConstructorInvocation, |
| DartType, |
| DynamicType, |
| Expression, |
| Extension, |
| Field, |
| FunctionNode, |
| FunctionType, |
| InterfaceType, |
| InvalidType, |
| Library, |
| LibraryDependency, |
| LibraryPart, |
| ListLiteral, |
| MapLiteral, |
| Member, |
| Name, |
| NeverType, |
| NonNullableByDefaultCompiledMode, |
| NullType, |
| Nullability, |
| Procedure, |
| ProcedureKind, |
| Reference, |
| SetLiteral, |
| StaticInvocation, |
| StringLiteral, |
| Supertype, |
| TypeParameter, |
| TypeParameterType, |
| Typedef, |
| VariableDeclaration, |
| Version, |
| VoidType; |
| |
| import 'package:kernel/class_hierarchy.dart' show ClassHierarchy; |
| |
| import 'package:kernel/clone.dart' show CloneVisitorNotMembers; |
| |
| import 'package:kernel/reference_from_index.dart' |
| show IndexedClass, IndexedLibrary; |
| |
| import 'package:kernel/src/bounds_checks.dart' |
| show |
| TypeArgumentIssue, |
| findTypeArgumentIssues, |
| findTypeArgumentIssuesForInvocation, |
| getGenericTypeName; |
| |
| import 'package:kernel/type_algebra.dart' show Substitution, substitute; |
| |
| import 'package:kernel/type_environment.dart' |
| show SubtypeCheckMode, TypeEnvironment; |
| |
| import '../../api_prototype/experimental_flags.dart'; |
| import '../../base/nnbd_mode.dart'; |
| |
| import '../builder/builder.dart'; |
| import '../builder/builtin_type_declaration_builder.dart'; |
| import '../builder/class_builder.dart'; |
| import '../builder/constructor_builder.dart'; |
| import '../builder/constructor_reference_builder.dart'; |
| import '../builder/dynamic_type_declaration_builder.dart'; |
| import '../builder/enum_builder.dart'; |
| import '../builder/extension_builder.dart'; |
| import '../builder/field_builder.dart'; |
| import '../builder/formal_parameter_builder.dart'; |
| import '../builder/function_builder.dart'; |
| import '../builder/function_type_builder.dart'; |
| import '../builder/invalid_type_declaration_builder.dart'; |
| import '../builder/library_builder.dart'; |
| import '../builder/member_builder.dart'; |
| import '../builder/metadata_builder.dart'; |
| import '../builder/mixin_application_builder.dart'; |
| import '../builder/name_iterator.dart'; |
| import '../builder/named_type_builder.dart'; |
| import '../builder/never_type_declaration_builder.dart'; |
| import '../builder/nullability_builder.dart'; |
| import '../builder/prefix_builder.dart'; |
| import '../builder/procedure_builder.dart'; |
| import '../builder/type_alias_builder.dart'; |
| import '../builder/type_builder.dart'; |
| import '../builder/type_declaration_builder.dart'; |
| import '../builder/type_variable_builder.dart'; |
| import '../builder/unresolved_type.dart'; |
| import '../builder/void_type_declaration_builder.dart'; |
| |
| import '../combinator.dart' show Combinator; |
| |
| import '../configuration.dart' show Configuration; |
| |
| import '../export.dart' show Export; |
| |
| import '../fasta_codes.dart'; |
| |
| import '../identifiers.dart' show QualifiedName, flattenName; |
| |
| import '../import.dart' show Import; |
| |
| import '../kernel/internal_ast.dart'; |
| |
| import '../kernel/kernel_builder.dart' |
| show |
| ImplicitFieldType, |
| LoadLibraryBuilder, |
| compareProcedures, |
| toKernelCombinators; |
| |
| import '../kernel/metadata_collector.dart'; |
| |
| import '../kernel/type_algorithms.dart' |
| show |
| calculateBounds, |
| computeTypeVariableBuilderVariance, |
| findGenericFunctionTypes, |
| getNonSimplicityIssuesForDeclaration, |
| getNonSimplicityIssuesForTypeVariables, |
| pendingVariance; |
| |
| import '../loader.dart' show Loader; |
| |
| import '../modifier.dart' |
| show |
| abstractMask, |
| constMask, |
| finalMask, |
| declaresConstConstructorMask, |
| hasInitializerMask, |
| initializingFormalMask, |
| lateMask, |
| mixinDeclarationMask, |
| namedMixinApplicationMask, |
| staticMask; |
| |
| import '../names.dart' show indexSetName; |
| |
| import '../problems.dart' show unexpected, unhandled; |
| |
| import '../scope.dart'; |
| |
| import '../type_inference/type_inferrer.dart' show TypeInferrerImpl; |
| |
| import 'source_class_builder.dart' show SourceClassBuilder; |
| |
| import 'source_extension_builder.dart' show SourceExtensionBuilder; |
| |
| import 'source_loader.dart' show SourceLoader; |
| |
| import 'source_type_alias_builder.dart'; |
| |
| class SourceLibraryBuilder extends LibraryBuilderImpl { |
| static const String MALFORMED_URI_SCHEME = "org-dartlang-malformed-uri"; |
| |
| final SourceLoader loader; |
| |
| final TypeParameterScopeBuilder libraryDeclaration; |
| |
| final List<ConstructorReferenceBuilder> constructorReferences = |
| <ConstructorReferenceBuilder>[]; |
| |
| final List<SourceLibraryBuilder> parts = <SourceLibraryBuilder>[]; |
| |
| // Can I use library.parts instead? See SourceLibraryBuilder.addPart. |
| final List<int> partOffsets = <int>[]; |
| |
| final List<Import> imports = <Import>[]; |
| |
| final List<Export> exports = <Export>[]; |
| |
| final Scope importScope; |
| |
| final Uri fileUri; |
| |
| final Uri _packageUri; |
| |
| Uri get packageUriForTesting => _packageUri; |
| |
| final List<ImplementationInfo> implementationBuilders = |
| <ImplementationInfo>[]; |
| |
| final List<Object> accessors = <Object>[]; |
| |
| String documentationComment; |
| |
| String name; |
| |
| String partOfName; |
| |
| Uri partOfUri; |
| |
| List<MetadataBuilder> metadata; |
| |
| /// The current declaration that is being built. When we start parsing a |
| /// declaration (class, method, and so on), we don't have enough information |
| /// to create a builder and this object records its members and types until, |
| /// for example, [addClass] is called. |
| TypeParameterScopeBuilder currentTypeParameterScopeBuilder; |
| |
| bool canAddImplementationBuilders = false; |
| |
| /// Non-null if this library causes an error upon access, that is, there was |
| /// an error reading its source. |
| Message accessProblem; |
| |
| @override |
| final Library library; |
| |
| final SourceLibraryBuilder actualOrigin; |
| |
| final List<FunctionBuilder> nativeMethods = <FunctionBuilder>[]; |
| |
| final List<TypeVariableBuilder> boundlessTypeVariables = |
| <TypeVariableBuilder>[]; |
| |
| // A list of alternating forwarders and the procedures they were generated |
| // for. Note that it may not include a forwarder-origin pair in cases when |
| // the former does not need to be updated after the body of the latter was |
| // built. |
| final List<Procedure> forwardersOrigins = <Procedure>[]; |
| |
| // List of types inferred in the outline. Errors in these should be reported |
| // differently than for specified types. |
| // TODO(dmitryas): Find a way to mark inferred types. |
| final Set<DartType> inferredTypes = new Set<DartType>.identity(); |
| |
| // While the bounds of type parameters aren't compiled yet, we can't tell the |
| // default nullability of the corresponding type-parameter types. This list |
| // is used to collect such type-parameter types in order to set the |
| // nullability after the bounds are built. |
| final List<TypeParameterType> pendingNullabilities = |
| new List<TypeParameterType>(); |
| |
| // A library to use for Names generated when compiling code in this library. |
| // This allows code generated in one library to use the private namespace of |
| // another, for example during expression compilation (debugging). |
| Library get nameOrigin => _nameOrigin ?? library; |
| final Library _nameOrigin; |
| |
| final Library referencesFrom; |
| final IndexedLibrary referencesFromIndexed; |
| IndexedClass _currentClassReferencesFromIndexed; |
| |
| /// Exports that can't be serialized. |
| /// |
| /// The key is the name of the exported member. |
| /// |
| /// If the name is `dynamic` or `void`, this library reexports the |
| /// corresponding type from `dart:core`, and the value is null. |
| /// |
| /// Otherwise, this represents an error (an ambiguous export). In this case, |
| /// the error message is the corresponding value in the map. |
| Map<String, String> unserializableExports; |
| |
| List<FieldBuilder> _implicitlyTypedFields; |
| |
| LanguageVersion _languageVersion; |
| |
| bool postponedProblemsIssued = false; |
| List<PostponedProblem> postponedProblems; |
| |
| /// List of [PrefixBuilder]s for imports with prefixes. |
| List<PrefixBuilder> _prefixBuilders; |
| |
| /// Set of extension declarations in scope. This is computed lazily in |
| /// [forEachExtensionInScope]. |
| Set<ExtensionBuilder> _extensionsInScope; |
| |
| SourceLibraryBuilder.internal( |
| SourceLoader loader, |
| Uri fileUri, |
| Uri packageUri, |
| Scope scope, |
| SourceLibraryBuilder actualOrigin, |
| Library library, |
| Library nameOrigin, |
| Library referencesFrom, |
| bool referenceIsPartOwner) |
| : this.fromScopes( |
| loader, |
| fileUri, |
| packageUri, |
| new TypeParameterScopeBuilder.library(), |
| scope ?? new Scope.top(), |
| actualOrigin, |
| library, |
| nameOrigin, |
| referencesFrom); |
| |
| SourceLibraryBuilder.fromScopes( |
| this.loader, |
| this.fileUri, |
| this._packageUri, |
| this.libraryDeclaration, |
| this.importScope, |
| this.actualOrigin, |
| this.library, |
| this._nameOrigin, |
| this.referencesFrom) |
| : _languageVersion = new ImplicitLanguageVersion(library.languageVersion), |
| currentTypeParameterScopeBuilder = libraryDeclaration, |
| referencesFromIndexed = |
| referencesFrom == null ? null : new IndexedLibrary(referencesFrom), |
| super( |
| fileUri, libraryDeclaration.toScope(importScope), new Scope.top()) { |
| assert( |
| _packageUri == null || |
| importUri.scheme != 'package' || |
| importUri.path.startsWith(_packageUri.path), |
| "Foreign package uri '$_packageUri' set on library with import uri " |
| "'${importUri}'."); |
| assert( |
| importUri.scheme != 'dart' || _packageUri == null, |
| "Package uri '$_packageUri' set on dart: library with import uri " |
| "'${importUri}'."); |
| } |
| |
| bool _enableVarianceInLibrary; |
| bool _enableNonfunctionTypeAliasesInLibrary; |
| bool _enableNonNullableInLibrary; |
| Version _enableNonNullableVersionInLibrary; |
| bool _enableTripleShiftInLibrary; |
| bool _enableExtensionMethodsInLibrary; |
| |
| bool get enableVarianceInLibrary => |
| _enableVarianceInLibrary ??= loader.target.isExperimentEnabledInLibrary( |
| ExperimentalFlag.variance, _packageUri ?? importUri); |
| |
| bool get enableNonfunctionTypeAliasesInLibrary => |
| _enableNonfunctionTypeAliasesInLibrary ??= loader.target |
| .isExperimentEnabledInLibrary(ExperimentalFlag.nonfunctionTypeAliases, |
| _packageUri ?? importUri); |
| |
| /// Returns `true` if the 'non-nullable' experiment is enabled for this |
| /// library. |
| /// |
| /// Note that the library might still opt out of the experiment by having |
| /// a version that is too low for opting in to the experiment. |
| bool get enableNonNullableInLibrary => _enableNonNullableInLibrary ??= |
| loader.target.isExperimentEnabledInLibrary( |
| ExperimentalFlag.nonNullable, _packageUri ?? importUri) && |
| !isOptOutTest(library.importUri); |
| |
| Version get enableNonNullableVersionInLibrary => |
| _enableNonNullableVersionInLibrary ??= loader.target |
| .getExperimentEnabledVersionInLibrary( |
| ExperimentalFlag.nonNullable, _packageUri ?? importUri); |
| |
| bool get enableTripleShiftInLibrary => _enableTripleShiftInLibrary ??= |
| loader.target.isExperimentEnabledInLibrary( |
| ExperimentalFlag.tripleShift, _packageUri ?? importUri); |
| |
| bool get enableExtensionMethodsInLibrary => |
| _enableExtensionMethodsInLibrary ??= loader.target |
| .isExperimentEnabledInLibrary( |
| ExperimentalFlag.extensionMethods, _packageUri ?? importUri); |
| |
| void updateLibraryNNBDSettings() { |
| library.isNonNullableByDefault = isNonNullableByDefault; |
| if (enableNonNullableInLibrary) { |
| switch (loader.nnbdMode) { |
| case NnbdMode.Weak: |
| library.nonNullableByDefaultCompiledMode = |
| NonNullableByDefaultCompiledMode.Weak; |
| break; |
| case NnbdMode.Strong: |
| library.nonNullableByDefaultCompiledMode = |
| NonNullableByDefaultCompiledMode.Strong; |
| break; |
| case NnbdMode.Agnostic: |
| library.nonNullableByDefaultCompiledMode = |
| NonNullableByDefaultCompiledMode.Agnostic; |
| break; |
| } |
| } else { |
| library.nonNullableByDefaultCompiledMode = |
| NonNullableByDefaultCompiledMode.Weak; |
| } |
| } |
| |
| SourceLibraryBuilder(Uri uri, Uri fileUri, Uri packageUri, Loader loader, |
| SourceLibraryBuilder actualOrigin, |
| {Scope scope, |
| Library target, |
| Library nameOrigin, |
| Library referencesFrom, |
| bool referenceIsPartOwner}) |
| : this.internal( |
| loader, |
| fileUri, |
| packageUri, |
| scope, |
| actualOrigin, |
| target ?? |
| (actualOrigin?.library ?? |
| new Library(uri, |
| fileUri: fileUri, |
| reference: referenceIsPartOwner == true |
| ? null |
| : referencesFrom?.reference) |
| ..setLanguageVersion(loader.target.currentSdkVersion)), |
| nameOrigin, |
| referencesFrom, |
| referenceIsPartOwner); |
| |
| @override |
| bool get isPart => partOfName != null || partOfUri != null; |
| |
| List<UnresolvedType> get types => libraryDeclaration.types; |
| |
| @override |
| bool get isSynthetic => accessProblem != null; |
| |
| TypeBuilder addType(TypeBuilder type, int charOffset) { |
| currentTypeParameterScopeBuilder |
| .addType(new UnresolvedType(type, charOffset, fileUri)); |
| return type; |
| } |
| |
| bool _isNonNullableByDefault; |
| |
| @override |
| bool get isNonNullableByDefault { |
| assert( |
| _isNonNullableByDefault == null || |
| _isNonNullableByDefault == _computeIsNonNullableByDefault(), |
| "Unstable isNonNullableByDefault property, changed " |
| "from ${_isNonNullableByDefault} to " |
| "${_computeIsNonNullableByDefault()}"); |
| return _ensureIsNonNullableByDefault(); |
| } |
| |
| bool _ensureIsNonNullableByDefault() { |
| if (_isNonNullableByDefault == null) { |
| _isNonNullableByDefault = _computeIsNonNullableByDefault(); |
| updateLibraryNNBDSettings(); |
| } |
| return _isNonNullableByDefault; |
| } |
| |
| bool _computeIsNonNullableByDefault() => |
| enableNonNullableInLibrary && |
| languageVersion.version >= enableNonNullableVersionInLibrary; |
| |
| static bool isOptOutTest(Uri uri) { |
| String path = uri.path; |
| for (String testDir in ['/tests/', '/generated_tests/']) { |
| int start = path.indexOf(testDir); |
| if (start == -1) continue; |
| String rest = path.substring(start + testDir.length); |
| return optOutTestPaths.any(rest.startsWith); |
| } |
| return false; |
| } |
| |
| static const List<String> optOutTestPaths = [ |
| 'co19_2/', |
| 'corelib_2/', |
| 'dart2js_2/', |
| 'ffi_2', |
| 'language_2/', |
| 'lib_2/', |
| 'service_2/', |
| 'standalone_2/', |
| 'vm/dart_2/', // in runtime/tests |
| ]; |
| |
| LanguageVersion get languageVersion => _languageVersion; |
| |
| void markLanguageVersionFinal() { |
| if (!isNonNullableByDefault && |
| (loader.nnbdMode == NnbdMode.Strong || |
| loader.nnbdMode == NnbdMode.Agnostic)) { |
| // In strong and agnostic mode, the language version is not allowed to |
| // opt a library out of nnbd. |
| if (_languageVersion.isExplicit) { |
| addPostponedProblem(messageStrongModeNNBDButOptOut, |
| _languageVersion.charOffset, _languageVersion.charCount, fileUri); |
| } else { |
| loader.registerStrongOptOutLibrary(this); |
| } |
| library.nonNullableByDefaultCompiledMode = |
| NonNullableByDefaultCompiledMode.Invalid; |
| loader.hasInvalidNnbdModeLibrary = true; |
| } |
| _languageVersion.isFinal = true; |
| _ensureIsNonNullableByDefault(); |
| } |
| |
| @override |
| void setLanguageVersion(Version version, |
| {int offset: 0, int length: noLength, bool explicit: false}) { |
| assert(!_languageVersion.isFinal); |
| if (languageVersion.isExplicit) return; |
| |
| if (version == null) { |
| addPostponedProblem( |
| messageLanguageVersionInvalidInDotPackages, offset, length, fileUri); |
| if (_languageVersion is ImplicitLanguageVersion) { |
| // If the package set an OK version, but the file set an invalid version |
| // we want to use the package version. |
| _languageVersion = new InvalidLanguageVersion( |
| fileUri, offset, length, explicit, loader.target.currentSdkVersion); |
| library.setLanguageVersion(_languageVersion.version); |
| } |
| return; |
| } |
| |
| // If trying to set a language version that is higher than the current sdk |
| // version it's an error. |
| if (version > loader.target.currentSdkVersion) { |
| addPostponedProblem( |
| templateLanguageVersionTooHigh.withArguments( |
| loader.target.currentSdkVersion.major, |
| loader.target.currentSdkVersion.minor), |
| offset, |
| length, |
| fileUri); |
| if (_languageVersion is ImplicitLanguageVersion) { |
| // If the package set an OK version, but the file set an invalid version |
| // we want to use the package version. |
| _languageVersion = new InvalidLanguageVersion( |
| fileUri, offset, length, explicit, loader.target.currentSdkVersion); |
| library.setLanguageVersion(_languageVersion.version); |
| } |
| return; |
| } |
| |
| _languageVersion = |
| new LanguageVersion(version, fileUri, offset, length, explicit); |
| library.setLanguageVersion(version); |
| } |
| |
| ConstructorReferenceBuilder addConstructorReference(Object name, |
| List<TypeBuilder> typeArguments, String suffix, int charOffset) { |
| ConstructorReferenceBuilder ref = new ConstructorReferenceBuilder( |
| name, typeArguments, suffix, this, charOffset); |
| constructorReferences.add(ref); |
| return ref; |
| } |
| |
| void beginNestedDeclaration(TypeParameterScopeKind kind, String name, |
| {bool hasMembers: true}) { |
| currentTypeParameterScopeBuilder = |
| currentTypeParameterScopeBuilder.createNested(kind, name, hasMembers); |
| } |
| |
| TypeParameterScopeBuilder endNestedDeclaration( |
| TypeParameterScopeKind kind, String name) { |
| assert( |
| currentTypeParameterScopeBuilder.kind == kind, |
| "Unexpected declaration. " |
| "Trying to end a ${currentTypeParameterScopeBuilder.kind} as a $kind."); |
| assert( |
| (name?.startsWith(currentTypeParameterScopeBuilder.name) ?? |
| (name == currentTypeParameterScopeBuilder.name)) || |
| currentTypeParameterScopeBuilder.name == "operator" || |
| identical(name, "<syntax-error>"), |
| "${name} != ${currentTypeParameterScopeBuilder.name}"); |
| TypeParameterScopeBuilder previous = currentTypeParameterScopeBuilder; |
| currentTypeParameterScopeBuilder = currentTypeParameterScopeBuilder.parent; |
| return previous; |
| } |
| |
| bool uriIsValid(Uri uri) => uri.scheme != MALFORMED_URI_SCHEME; |
| |
| Uri resolve(Uri baseUri, String uri, int uriOffset, {isPart: false}) { |
| if (uri == null) { |
| addProblem(messageExpectedUri, uriOffset, noLength, fileUri); |
| return new Uri(scheme: MALFORMED_URI_SCHEME); |
| } |
| Uri parsedUri; |
| try { |
| parsedUri = Uri.parse(uri); |
| } on FormatException catch (e) { |
| // Point to position in string indicated by the exception, |
| // or to the initial quote if no position is given. |
| // (Assumes the directive is using a single-line string.) |
| addProblem(templateCouldNotParseUri.withArguments(uri, e.message), |
| uriOffset + 1 + (e.offset ?? -1), 1, fileUri); |
| return new Uri( |
| scheme: MALFORMED_URI_SCHEME, query: Uri.encodeQueryComponent(uri)); |
| } |
| if (isPart && baseUri.scheme == "dart") { |
| // Resolve using special rules for dart: URIs |
| return resolveRelativeUri(baseUri, parsedUri); |
| } else { |
| return baseUri.resolveUri(parsedUri); |
| } |
| } |
| |
| String computeAndValidateConstructorName(Object name, int charOffset, |
| {isFactory: false}) { |
| String className = currentTypeParameterScopeBuilder.name; |
| String prefix; |
| String suffix; |
| if (name is QualifiedName) { |
| prefix = name.qualifier; |
| suffix = name.name; |
| } else { |
| prefix = name; |
| suffix = null; |
| } |
| if (prefix == className) { |
| return suffix ?? ""; |
| } |
| if (suffix == null && !isFactory) { |
| // A legal name for a regular method, but not for a constructor. |
| return null; |
| } |
| |
| addProblem( |
| messageConstructorWithWrongName, charOffset, prefix.length, fileUri, |
| context: [ |
| templateConstructorWithWrongNameContext |
| .withArguments(currentTypeParameterScopeBuilder.name) |
| .withLocation( |
| importUri, |
| currentTypeParameterScopeBuilder.charOffset, |
| currentTypeParameterScopeBuilder.name.length) |
| ]); |
| |
| return suffix; |
| } |
| |
| void addExport( |
| List<MetadataBuilder> metadata, |
| String uri, |
| List<Configuration> configurations, |
| List<Combinator> combinators, |
| int charOffset, |
| int uriOffset) { |
| if (configurations != null) { |
| for (Configuration config in configurations) { |
| if (lookupImportCondition(config.dottedName) == config.condition) { |
| uri = config.importUri; |
| break; |
| } |
| } |
| } |
| |
| LibraryBuilder exportedLibrary = loader.read( |
| resolve(this.importUri, uri, uriOffset), charOffset, |
| accessor: this); |
| exportedLibrary.addExporter(this, combinators, charOffset); |
| exports.add(new Export(this, exportedLibrary, combinators, charOffset)); |
| } |
| |
| String lookupImportCondition(String dottedName) { |
| const String prefix = "dart.library."; |
| if (!dottedName.startsWith(prefix)) return ""; |
| dottedName = dottedName.substring(prefix.length); |
| if (!loader.target.uriTranslator.isLibrarySupported(dottedName)) return ""; |
| |
| LibraryBuilder imported = |
| loader.builders[new Uri(scheme: "dart", path: dottedName)]; |
| |
| if (imported == null) { |
| LibraryBuilder coreLibrary = loader.read( |
| resolve(this.importUri, |
| new Uri(scheme: "dart", path: "core").toString(), -1), |
| -1, |
| accessor: loader.first); |
| imported = coreLibrary |
| .loader.builders[new Uri(scheme: 'dart', path: dottedName)]; |
| } |
| return imported != null && !imported.isSynthetic ? "true" : ""; |
| } |
| |
| void addImport( |
| List<MetadataBuilder> metadata, |
| String uri, |
| List<Configuration> configurations, |
| String prefix, |
| List<Combinator> combinators, |
| bool deferred, |
| int charOffset, |
| int prefixCharOffset, |
| int uriOffset, |
| int importIndex) { |
| if (configurations != null) { |
| for (Configuration config in configurations) { |
| if (lookupImportCondition(config.dottedName) == config.condition) { |
| uri = config.importUri; |
| break; |
| } |
| } |
| } |
| |
| LibraryBuilder builder = null; |
| |
| Uri resolvedUri; |
| String nativePath; |
| const String nativeExtensionScheme = "dart-ext:"; |
| if (uri.startsWith(nativeExtensionScheme)) { |
| String strippedUri = uri.substring(nativeExtensionScheme.length); |
| if (strippedUri.startsWith("package")) { |
| resolvedUri = resolve(this.importUri, strippedUri, |
| uriOffset + nativeExtensionScheme.length); |
| resolvedUri = loader.target.translateUri(resolvedUri); |
| nativePath = resolvedUri.toString(); |
| } else { |
| resolvedUri = new Uri(scheme: "dart-ext", pathSegments: [uri]); |
| nativePath = uri; |
| } |
| } else { |
| resolvedUri = resolve(this.importUri, uri, uriOffset); |
| builder = loader.read(resolvedUri, uriOffset, accessor: this); |
| } |
| |
| imports.add(new Import(this, builder, deferred, prefix, combinators, |
| configurations, charOffset, prefixCharOffset, importIndex, |
| nativeImportPath: nativePath)); |
| } |
| |
| void addPart(List<MetadataBuilder> metadata, String uri, int charOffset) { |
| Uri resolvedUri; |
| Uri newFileUri; |
| resolvedUri = resolve(this.importUri, uri, charOffset, isPart: true); |
| newFileUri = resolve(fileUri, uri, charOffset); |
| // TODO(johnniwinther): Add a LibraryPartBuilder instead of using |
| // [LibraryBuilder] to represent both libraries and parts. |
| parts.add(loader.read(resolvedUri, charOffset, |
| fileUri: newFileUri, accessor: this)); |
| partOffsets.add(charOffset); |
| |
| // TODO(ahe): [metadata] should be stored, evaluated, and added to [part]. |
| LibraryPart part = new LibraryPart(<Expression>[], uri) |
| ..fileOffset = charOffset; |
| library.addPart(part); |
| } |
| |
| void addPartOf( |
| List<MetadataBuilder> metadata, String name, String uri, int uriOffset) { |
| partOfName = name; |
| if (uri != null) { |
| partOfUri = resolve(this.importUri, uri, uriOffset); |
| Uri newFileUri = resolve(fileUri, uri, uriOffset); |
| LibraryBuilder library = loader.read(partOfUri, uriOffset, |
| fileUri: newFileUri, accessor: this); |
| if (loader.first == this) { |
| // This is a part, and it was the first input. Let the loader know |
| // about that. |
| loader.first = library; |
| } |
| } |
| } |
| |
| void addFields( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| int modifiers, |
| bool isTopLevel, |
| TypeBuilder type, |
| List<FieldInfo> fieldInfos) { |
| for (FieldInfo info in fieldInfos) { |
| bool isConst = modifiers & constMask != 0; |
| bool isFinal = modifiers & finalMask != 0; |
| bool potentiallyNeedInitializerInOutline = isConst || isFinal; |
| Token startToken; |
| if (potentiallyNeedInitializerInOutline || type == null) { |
| startToken = info.initializerToken; |
| } |
| if (startToken != null) { |
| // Extract only the tokens for the initializer expression from the |
| // token stream. |
| Token endToken = info.beforeLast; |
| endToken.setNext(new Token.eof(endToken.next.offset)); |
| new Token.eof(startToken.previous.offset).setNext(startToken); |
| } |
| bool hasInitializer = info.initializerToken != null; |
| addField( |
| documentationComment, |
| metadata, |
| modifiers, |
| isTopLevel, |
| type, |
| info.name, |
| info.charOffset, |
| info.charEndOffset, |
| startToken, |
| hasInitializer, |
| constInitializerToken: |
| potentiallyNeedInitializerInOutline ? startToken : null); |
| } |
| } |
| |
| @override |
| Builder addBuilder(String name, Builder declaration, int charOffset, |
| {Reference getterReference, Reference setterReference}) { |
| // TODO(ahe): Set the parent correctly here. Could then change the |
| // implementation of MemberBuilder.isTopLevel to test explicitly for a |
| // LibraryBuilder. |
| if (name == null) { |
| unhandled("null", "name", charOffset, fileUri); |
| } |
| if (getterReference != null) { |
| loader.buildersCreatedWithReferences[getterReference] = declaration; |
| } |
| if (setterReference != null) { |
| loader.buildersCreatedWithReferences[setterReference] = declaration; |
| } |
| if (currentTypeParameterScopeBuilder == libraryDeclaration) { |
| if (declaration is MemberBuilder) { |
| declaration.parent = this; |
| } else if (declaration is TypeDeclarationBuilder) { |
| declaration.parent = this; |
| } else if (declaration is PrefixBuilder) { |
| assert(declaration.parent == this); |
| } else { |
| return unhandled( |
| "${declaration.runtimeType}", "addBuilder", charOffset, fileUri); |
| } |
| } else { |
| assert(currentTypeParameterScopeBuilder.parent == libraryDeclaration); |
| } |
| bool isConstructor = declaration is FunctionBuilder && |
| (declaration.isConstructor || declaration.isFactory); |
| if (!isConstructor && name == currentTypeParameterScopeBuilder.name) { |
| addProblem( |
| messageMemberWithSameNameAsClass, charOffset, noLength, fileUri); |
| } |
| Map<String, Builder> members = isConstructor |
| ? currentTypeParameterScopeBuilder.constructors |
| : (declaration.isSetter |
| ? currentTypeParameterScopeBuilder.setters |
| : currentTypeParameterScopeBuilder.members); |
| Builder existing = members[name]; |
| |
| if (existing == declaration) return existing; |
| |
| if (declaration.next != null && declaration.next != existing) { |
| unexpected( |
| "${declaration.next.fileUri}@${declaration.next.charOffset}", |
| "${existing?.fileUri}@${existing?.charOffset}", |
| declaration.charOffset, |
| declaration.fileUri); |
| } |
| declaration.next = existing; |
| if (declaration is PrefixBuilder && existing is PrefixBuilder) { |
| assert(existing.next is! PrefixBuilder); |
| Builder deferred; |
| Builder other; |
| if (declaration.deferred) { |
| deferred = declaration; |
| other = existing; |
| } else if (existing.deferred) { |
| deferred = existing; |
| other = declaration; |
| } |
| if (deferred != null) { |
| addProblem(templateDeferredPrefixDuplicated.withArguments(name), |
| deferred.charOffset, noLength, fileUri, |
| context: [ |
| templateDeferredPrefixDuplicatedCause |
| .withArguments(name) |
| .withLocation(fileUri, other.charOffset, noLength) |
| ]); |
| } |
| return existing |
| ..exportScope.merge(declaration.exportScope, |
| (String name, Builder existing, Builder member) { |
| return computeAmbiguousDeclaration( |
| name, existing, member, charOffset); |
| }); |
| } else if (isDuplicatedDeclaration(existing, declaration)) { |
| String fullName = name; |
| if (isConstructor) { |
| if (name.isEmpty) { |
| fullName = currentTypeParameterScopeBuilder.name; |
| } else { |
| fullName = "${currentTypeParameterScopeBuilder.name}.$name"; |
| } |
| } |
| addProblem(templateDuplicatedDeclaration.withArguments(fullName), |
| charOffset, fullName.length, declaration.fileUri, |
| context: <LocatedMessage>[ |
| templateDuplicatedDeclarationCause |
| .withArguments(fullName) |
| .withLocation( |
| existing.fileUri, existing.charOffset, fullName.length) |
| ]); |
| } else if (declaration.isExtension) { |
| // We add the extension declaration to the extension scope only if its |
| // name is unique. Only the first of duplicate extensions is accessible |
| // by name or by resolution and the remaining are dropped for the output. |
| currentTypeParameterScopeBuilder.extensions.add(declaration); |
| } |
| if (declaration is PrefixBuilder) { |
| _prefixBuilders ??= <PrefixBuilder>[]; |
| _prefixBuilders.add(declaration); |
| } |
| return members[name] = declaration; |
| } |
| |
| bool isDuplicatedDeclaration(Builder existing, Builder other) { |
| if (existing == null) return false; |
| Builder next = existing.next; |
| if (next == null) { |
| if (existing.isGetter && other.isSetter) return false; |
| if (existing.isSetter && other.isGetter) return false; |
| } else { |
| if (next is ClassBuilder && !next.isMixinApplication) return true; |
| } |
| if (existing is ClassBuilder && other is ClassBuilder) { |
| // We allow multiple mixin applications with the same name. An |
| // alternative is to share these mixin applications. This situation can |
| // happen if you have `class A extends Object with Mixin {}` and `class B |
| // extends Object with Mixin {}` in the same library. |
| return !existing.isMixinApplication || !other.isMixinApplication; |
| } |
| return true; |
| } |
| |
| /// Builds the core AST structure of this library as needed for the outline. |
| Library build(LibraryBuilder coreLibrary, {bool modifyTarget}) { |
| assert(implementationBuilders.isEmpty); |
| canAddImplementationBuilders = true; |
| Iterator<Builder> iterator = this.iterator; |
| while (iterator.moveNext()) { |
| buildBuilder(iterator.current, coreLibrary); |
| } |
| for (ImplementationInfo info in implementationBuilders) { |
| String name = info.name; |
| Builder declaration = info.declaration; |
| int charOffset = info.charOffset; |
| addBuilder(name, declaration, charOffset); |
| buildBuilder(declaration, coreLibrary); |
| } |
| canAddImplementationBuilders = false; |
| |
| scope.forEachLocalSetter((String name, Builder setter) { |
| Builder member = scopeBuilder[name]; |
| if (member == null || |
| !member.isField || |
| member.isFinal || |
| member.isConst) { |
| return; |
| } |
| addProblem(templateConflictsWithMember.withArguments(name), |
| setter.charOffset, noLength, fileUri); |
| // TODO(ahe): Context to previous message? |
| addProblem(templateConflictsWithSetter.withArguments(name), |
| member.charOffset, noLength, fileUri); |
| }); |
| |
| if (modifyTarget == false) return library; |
| |
| library.isSynthetic = isSynthetic; |
| addDependencies(library, new Set<SourceLibraryBuilder>()); |
| |
| loader.target.metadataCollector |
| ?.setDocumentationComment(library, documentationComment); |
| |
| library.name = name; |
| library.procedures.sort(compareProcedures); |
| |
| if (unserializableExports != null) { |
| Field referenceFrom = referencesFromIndexed?.lookupField("_exports#"); |
| library.addField(new Field(new Name("_exports#", library), |
| initializer: new StringLiteral(jsonEncode(unserializableExports)), |
| isStatic: true, |
| isConst: true, |
| getterReference: referenceFrom?.getterReference, |
| setterReference: referenceFrom?.setterReference)); |
| } |
| |
| return library; |
| } |
| |
| /// Used to add implementation builder during the call to [build] above. |
| /// Currently, only anonymous mixins are using implementation builders (see |
| /// [MixinApplicationBuilder] |
| /// (../kernel/kernel_mixin_application_builder.dart)). |
| void addImplementationBuilder( |
| String name, Builder declaration, int charOffset) { |
| assert(canAddImplementationBuilders, "$importUri"); |
| implementationBuilders |
| .add(new ImplementationInfo(name, declaration, charOffset)); |
| } |
| |
| void validatePart(SourceLibraryBuilder library, Set<Uri> usedParts) { |
| if (library != null && parts.isNotEmpty) { |
| // If [library] is null, we have already reported a problem that this |
| // part is orphaned. |
| List<LocatedMessage> context = <LocatedMessage>[ |
| messagePartInPartLibraryContext.withLocation(library.fileUri, -1, 1), |
| ]; |
| for (int offset in partOffsets) { |
| addProblem(messagePartInPart, offset, noLength, fileUri, |
| context: context); |
| } |
| for (SourceLibraryBuilder part in parts) { |
| // Mark this part as used so we don't report it as orphaned. |
| usedParts.add(part.importUri); |
| } |
| } |
| parts.clear(); |
| if (exporters.isNotEmpty) { |
| List<LocatedMessage> context = <LocatedMessage>[ |
| messagePartExportContext.withLocation(fileUri, -1, 1), |
| ]; |
| for (Export export in exporters) { |
| export.exporter.addProblem( |
| messagePartExport, export.charOffset, "export".length, null, |
| context: context); |
| } |
| } |
| } |
| |
| void includeParts(Set<Uri> usedParts) { |
| Set<Uri> seenParts = new Set<Uri>(); |
| for (int i = 0; i < parts.length; i++) { |
| SourceLibraryBuilder part = parts[i]; |
| int partOffset = partOffsets[i]; |
| if (part == this) { |
| addProblem(messagePartOfSelf, -1, noLength, fileUri); |
| } else if (seenParts.add(part.fileUri)) { |
| if (part.partOfLibrary != null) { |
| addProblem(messagePartOfTwoLibraries, -1, noLength, part.fileUri, |
| context: [ |
| messagePartOfTwoLibrariesContext.withLocation( |
| part.partOfLibrary.fileUri, -1, noLength), |
| messagePartOfTwoLibrariesContext.withLocation( |
| this.fileUri, -1, noLength) |
| ]); |
| } else { |
| if (isPatch) { |
| usedParts.add(part.fileUri); |
| } else { |
| usedParts.add(part.importUri); |
| } |
| includePart(part, usedParts, partOffset); |
| } |
| } else { |
| addProblem(templatePartTwice.withArguments(part.fileUri), -1, noLength, |
| fileUri); |
| } |
| } |
| } |
| |
| bool includePart( |
| SourceLibraryBuilder part, Set<Uri> usedParts, int partOffset) { |
| if (part.partOfUri != null) { |
| if (uriIsValid(part.partOfUri) && part.partOfUri != importUri) { |
| // This is an error, but the part is not removed from the list of parts, |
| // so that metadata annotations can be associated with it. |
| addProblem( |
| templatePartOfUriMismatch.withArguments( |
| part.fileUri, importUri, part.partOfUri), |
| partOffset, |
| noLength, |
| fileUri); |
| return false; |
| } |
| } else if (part.partOfName != null) { |
| if (name != null) { |
| if (part.partOfName != name) { |
| // This is an error, but the part is not removed from the list of |
| // parts, so that metadata annotations can be associated with it. |
| addProblem( |
| templatePartOfLibraryNameMismatch.withArguments( |
| part.fileUri, name, part.partOfName), |
| partOffset, |
| noLength, |
| fileUri); |
| return false; |
| } |
| } else { |
| // This is an error, but the part is not removed from the list of parts, |
| // so that metadata annotations can be associated with it. |
| addProblem( |
| templatePartOfUseUri.withArguments( |
| part.fileUri, fileUri, part.partOfName), |
| partOffset, |
| noLength, |
| fileUri); |
| return false; |
| } |
| } else { |
| // This is an error, but the part is not removed from the list of parts, |
| // so that metadata annotations can be associated with it. |
| assert(!part.isPart); |
| if (uriIsValid(part.fileUri)) { |
| addProblem(templateMissingPartOf.withArguments(part.fileUri), |
| partOffset, noLength, fileUri); |
| } |
| return false; |
| } |
| |
| // Language versions have to match. Except if (at least) one of them is |
| // invalid in which case we've already gotten an error about this. |
| if (languageVersion != part.languageVersion && |
| languageVersion.valid && |
| part.languageVersion.valid) { |
| // This is an error, but the part is not removed from the list of |
| // parts, so that metadata annotations can be associated with it. |
| List<LocatedMessage> context = <LocatedMessage>[]; |
| if (languageVersion.isExplicit) { |
| context.add(messageLanguageVersionLibraryContext.withLocation( |
| languageVersion.fileUri, |
| languageVersion.charOffset, |
| languageVersion.charCount)); |
| } |
| if (part.languageVersion.isExplicit) { |
| context.add(messageLanguageVersionPartContext.withLocation( |
| part.languageVersion.fileUri, |
| part.languageVersion.charOffset, |
| part.languageVersion.charCount)); |
| } |
| addProblem( |
| messageLanguageVersionMismatchInPart, partOffset, noLength, fileUri, |
| context: context); |
| } |
| |
| part.validatePart(this, usedParts); |
| NameIterator partDeclarations = part.nameIterator; |
| while (partDeclarations.moveNext()) { |
| String name = partDeclarations.name; |
| Builder declaration = partDeclarations.current; |
| |
| if (declaration.next != null) { |
| List<Builder> duplicated = <Builder>[]; |
| while (declaration.next != null) { |
| duplicated.add(declaration); |
| partDeclarations.moveNext(); |
| declaration = partDeclarations.current; |
| } |
| duplicated.add(declaration); |
| // Handle duplicated declarations in the part. |
| // |
| // Duplicated declarations are handled by creating a linked list using |
| // the `next` field. This is preferred over making all scope entries be |
| // a `List<Declaration>`. |
| // |
| // We maintain the linked list so that the last entry is easy to |
| // recognize (it's `next` field is null). This means that it is |
| // reversed with respect to source code order. Since kernel doesn't |
| // allow duplicated declarations, we ensure that we only add the first |
| // declaration to the kernel tree. |
| // |
| // Since the duplicated declarations are stored in reverse order, we |
| // iterate over them in reverse order as this is simpler and normally |
| // not a problem. However, in this case we need to call [addBuilder] in |
| // source order as it would otherwise create cycles. |
| // |
| // We also need to be careful preserving the order of the links. The |
| // part library still keeps these declarations in its scope so that |
| // DietListener can find them. |
| for (int i = duplicated.length; i > 0; i--) { |
| Builder declaration = duplicated[i - 1]; |
| // No reference: There should be no duplicates when using references. |
| addBuilder(name, declaration, declaration.charOffset); |
| } |
| } else { |
| // No reference: The part is in the same loader so the reference |
| // - if needed - was already added. |
| addBuilder(name, declaration, declaration.charOffset); |
| } |
| } |
| types.addAll(part.types); |
| constructorReferences.addAll(part.constructorReferences); |
| part.partOfLibrary = this; |
| part.scope.becomePartOf(scope); |
| // TODO(ahe): Include metadata from part? |
| |
| nativeMethods.addAll(part.nativeMethods); |
| boundlessTypeVariables.addAll(part.boundlessTypeVariables); |
| // Check that the targets are different. This is not normally a problem |
| // but is for patch files. |
| if (library != part.library && part.library.problemsAsJson != null) { |
| library.problemsAsJson ??= <String>[]; |
| library.problemsAsJson.addAll(part.library.problemsAsJson); |
| } |
| List<FieldBuilder> partImplicitlyTypedFields = |
| part.takeImplicitlyTypedFields(); |
| if (partImplicitlyTypedFields != null) { |
| if (_implicitlyTypedFields == null) { |
| _implicitlyTypedFields = partImplicitlyTypedFields; |
| } else { |
| _implicitlyTypedFields.addAll(partImplicitlyTypedFields); |
| } |
| } |
| return true; |
| } |
| |
| void buildInitialScopes() { |
| NameIterator iterator = nameIterator; |
| while (iterator.moveNext()) { |
| addToExportScope(iterator.name, iterator.current); |
| } |
| } |
| |
| void addImportsToScope() { |
| bool explicitCoreImport = this == loader.coreLibrary; |
| for (Import import in imports) { |
| if (import.imported == loader.coreLibrary) { |
| explicitCoreImport = true; |
| } |
| if (import.imported?.isPart ?? false) { |
| addProblem( |
| templatePartOfInLibrary.withArguments(import.imported.fileUri), |
| import.charOffset, |
| noLength, |
| fileUri); |
| } |
| import.finalizeImports(this); |
| } |
| if (!explicitCoreImport) { |
| loader.coreLibrary.exportScope.forEach((String name, Builder member) { |
| addToScope(name, member, -1, true); |
| }); |
| } |
| |
| exportScope.forEach((String name, Builder member) { |
| if (member.parent != this) { |
| switch (name) { |
| case "dynamic": |
| case "void": |
| case "Never": |
| unserializableExports ??= <String, String>{}; |
| unserializableExports[name] = null; |
| break; |
| |
| default: |
| if (member is InvalidTypeDeclarationBuilder) { |
| unserializableExports ??= <String, String>{}; |
| unserializableExports[name] = member.message.message; |
| } else { |
| // Eventually (in #buildBuilder) members aren't added to the |
| // library if the have 'next' pointers, so don't add them as |
| // additionalExports either. Add the last one only (the one that |
| // will eventually be added to the library). |
| Builder memberLast = member; |
| while (memberLast.next != null) { |
| memberLast = memberLast.next; |
| } |
| if (memberLast is ClassBuilder) { |
| library.additionalExports.add(memberLast.cls.reference); |
| } else if (memberLast is TypeAliasBuilder) { |
| library.additionalExports.add(memberLast.typedef.reference); |
| } else if (memberLast is ExtensionBuilder) { |
| library.additionalExports.add(memberLast.extension.reference); |
| } else if (memberLast is MemberBuilder) { |
| for (Member member in memberLast.exportedMembers) { |
| if (member is Field) { |
| // For fields add both getter and setter references |
| // so replacing a field with a getter/setter pair still |
| // exports correctly. |
| library.additionalExports.add(member.getterReference); |
| library.additionalExports.add(member.setterReference); |
| } else { |
| library.additionalExports.add(member.reference); |
| } |
| } |
| } else { |
| unhandled('member', 'exportScope', memberLast.charOffset, |
| memberLast.fileUri); |
| } |
| } |
| } |
| } |
| }); |
| } |
| |
| @override |
| void addToScope(String name, Builder member, int charOffset, bool isImport) { |
| Builder existing = |
| importScope.lookupLocalMember(name, setter: member.isSetter); |
| if (existing != null) { |
| if (existing != member) { |
| importScope.addLocalMember( |
| name, |
| computeAmbiguousDeclaration(name, existing, member, charOffset, |
| isImport: isImport), |
| setter: member.isSetter); |
| } |
| } else { |
| importScope.addLocalMember(name, member, setter: member.isSetter); |
| } |
| if (member.isExtension) { |
| importScope.addExtension(member); |
| } |
| } |
| |
| /// Resolves all unresolved types in [types]. The list of types is cleared |
| /// when done. |
| int resolveTypes() { |
| int typeCount = types.length; |
| for (UnresolvedType t in types) { |
| t.resolveIn(scope, this); |
| t.checkType(this); |
| } |
| types.clear(); |
| return typeCount; |
| } |
| |
| @override |
| int resolveConstructors(_) { |
| int count = 0; |
| Iterator<Builder> iterator = this.iterator; |
| while (iterator.moveNext()) { |
| count += iterator.current.resolveConstructors(this); |
| } |
| return count; |
| } |
| |
| @override |
| String get fullNameForErrors { |
| // TODO(ahe): Consider if we should use relativizeUri here. The downside to |
| // doing that is that this URI may be used in an error message. Ideally, we |
| // should create a class that represents qualified names that we can |
| // relativize when printing a message, but still store the full URI in |
| // .dill files. |
| return name ?? "<library '$fileUri'>"; |
| } |
| |
| @override |
| void recordAccess(int charOffset, int length, Uri fileUri) { |
| accessors.add(fileUri); |
| accessors.add(charOffset); |
| accessors.add(length); |
| if (accessProblem != null) { |
| addProblem(accessProblem, charOffset, length, fileUri); |
| } |
| } |
| |
| void addProblemAtAccessors(Message message) { |
| if (accessProblem == null) { |
| if (accessors.isEmpty && this == loader.first) { |
| // This is the entry point library, and nobody access it directly. So |
| // we need to report a problem. |
| loader.addProblem(message, -1, 1, null); |
| } |
| for (int i = 0; i < accessors.length; i += 3) { |
| Uri accessor = accessors[i]; |
| int charOffset = accessors[i + 1]; |
| int length = accessors[i + 2]; |
| addProblem(message, charOffset, length, accessor); |
| } |
| accessProblem = message; |
| } |
| } |
| |
| @override |
| SourceLibraryBuilder get origin => actualOrigin ?? this; |
| |
| Uri get importUri => library.importUri; |
| |
| void addSyntheticDeclarationOfDynamic() { |
| addBuilder("dynamic", |
| new DynamicTypeDeclarationBuilder(const DynamicType(), this, -1), -1); |
| } |
| |
| void addSyntheticDeclarationOfNever() { |
| addBuilder( |
| "Never", |
| new NeverTypeDeclarationBuilder( |
| const NeverType(Nullability.nonNullable), this, -1), |
| -1); |
| } |
| |
| void addSyntheticDeclarationOfNull() { |
| // TODO(dmitryas): Uncomment the following when the Null class is removed |
| // from the SDK. |
| //addBuilder("Null", new NullTypeBuilder(const NullType(), this, -1), -1); |
| } |
| |
| TypeBuilder addNamedType(Object name, NullabilityBuilder nullabilityBuilder, |
| List<TypeBuilder> arguments, int charOffset) { |
| return addType( |
| new NamedTypeBuilder( |
| name, nullabilityBuilder, arguments, fileUri, charOffset), |
| charOffset); |
| } |
| |
| TypeBuilder addMixinApplication( |
| TypeBuilder supertype, List<TypeBuilder> mixins, int charOffset) { |
| return addType( |
| new MixinApplicationBuilder(supertype, mixins, fileUri, charOffset), |
| charOffset); |
| } |
| |
| TypeBuilder addVoidType(int charOffset) { |
| // 'void' is always nullable. |
| return addNamedType( |
| "void", const NullabilityBuilder.nullable(), null, charOffset) |
| ..bind( |
| new VoidTypeDeclarationBuilder(const VoidType(), this, charOffset)); |
| } |
| |
| /// Add a problem that might not be reported immediately. |
| /// |
| /// Problems will be issued after source information has been added. |
| /// Once the problems has been issued, adding a new "postponed" problem will |
| /// be issued immediately. |
| void addPostponedProblem( |
| Message message, int charOffset, int length, Uri fileUri) { |
| if (postponedProblemsIssued) { |
| addProblem(message, charOffset, length, fileUri); |
| } else { |
| postponedProblems ??= <PostponedProblem>[]; |
| postponedProblems |
| .add(new PostponedProblem(message, charOffset, length, fileUri)); |
| } |
| } |
| |
| void issuePostponedProblems() { |
| postponedProblemsIssued = true; |
| if (postponedProblems == null) return; |
| for (int i = 0; i < postponedProblems.length; ++i) { |
| PostponedProblem postponedProblem = postponedProblems[i]; |
| addProblem(postponedProblem.message, postponedProblem.charOffset, |
| postponedProblem.length, postponedProblem.fileUri); |
| } |
| postponedProblems = null; |
| } |
| |
| @override |
| FormattedMessage addProblem( |
| Message message, int charOffset, int length, Uri fileUri, |
| {bool wasHandled: false, |
| List<LocatedMessage> context, |
| Severity severity, |
| bool problemOnLibrary: false}) { |
| FormattedMessage formattedMessage = super.addProblem( |
| message, charOffset, length, fileUri, |
| wasHandled: wasHandled, |
| context: context, |
| severity: severity, |
| problemOnLibrary: true); |
| if (formattedMessage != null) { |
| library.problemsAsJson ??= <String>[]; |
| library.problemsAsJson.add(formattedMessage.toJsonString()); |
| } |
| return formattedMessage; |
| } |
| |
| void addClass( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| int modifiers, |
| String className, |
| List<TypeVariableBuilder> typeVariables, |
| TypeBuilder supertype, |
| List<TypeBuilder> interfaces, |
| int startOffset, |
| int nameOffset, |
| int endOffset, |
| int supertypeOffset) { |
| _addClass( |
| TypeParameterScopeKind.classDeclaration, |
| documentationComment, |
| metadata, |
| modifiers, |
| className, |
| typeVariables, |
| supertype, |
| interfaces, |
| startOffset, |
| nameOffset, |
| endOffset, |
| supertypeOffset); |
| } |
| |
| void addMixinDeclaration( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| int modifiers, |
| String className, |
| List<TypeVariableBuilder> typeVariables, |
| TypeBuilder supertype, |
| List<TypeBuilder> interfaces, |
| int startOffset, |
| int nameOffset, |
| int endOffset, |
| int supertypeOffset) { |
| _addClass( |
| TypeParameterScopeKind.mixinDeclaration, |
| documentationComment, |
| metadata, |
| modifiers, |
| className, |
| typeVariables, |
| supertype, |
| interfaces, |
| startOffset, |
| nameOffset, |
| endOffset, |
| supertypeOffset); |
| } |
| |
| void _addClass( |
| TypeParameterScopeKind kind, |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| int modifiers, |
| String className, |
| List<TypeVariableBuilder> typeVariables, |
| TypeBuilder supertype, |
| List<TypeBuilder> interfaces, |
| int startOffset, |
| int nameOffset, |
| int endOffset, |
| int supertypeOffset) { |
| // Nested declaration began in `OutlineBuilder.beginClassDeclaration`. |
| TypeParameterScopeBuilder declaration = |
| endNestedDeclaration(kind, className) |
| ..resolveTypes(typeVariables, this); |
| assert(declaration.parent == libraryDeclaration); |
| Map<String, MemberBuilder> members = declaration.members; |
| Map<String, MemberBuilder> constructors = declaration.constructors; |
| Map<String, MemberBuilder> setters = declaration.setters; |
| |
| Scope classScope = new Scope( |
| local: members, |
| setters: setters, |
| parent: scope.withTypeVariables(typeVariables), |
| debugName: "class $className", |
| isModifiable: false); |
| |
| // When looking up a constructor, we don't consider type variables or the |
| // library scope. |
| ConstructorScope constructorScope = |
| new ConstructorScope(className, constructors); |
| bool isMixinDeclaration = false; |
| if (modifiers & mixinDeclarationMask != 0) { |
| isMixinDeclaration = true; |
| modifiers = (modifiers & ~mixinDeclarationMask) | abstractMask; |
| } |
| if (declaration.declaresConstConstructor) { |
| modifiers |= declaresConstConstructorMask; |
| } |
| Class referencesFromClass; |
| if (referencesFrom != null) { |
| referencesFromClass = referencesFromIndexed.lookupClass(className); |
| assert(referencesFromClass == null || |
| _currentClassReferencesFromIndexed != null); |
| } |
| ClassBuilder classBuilder = new SourceClassBuilder( |
| metadata, |
| modifiers, |
| className, |
| typeVariables, |
| applyMixins(supertype, startOffset, nameOffset, endOffset, className, |
| isMixinDeclaration, |
| typeVariables: typeVariables), |
| interfaces, |
| // TODO(johnniwinther): Add the `on` clause types of a mixin declaration |
| // here. |
| null, |
| classScope, |
| constructorScope, |
| this, |
| new List<ConstructorReferenceBuilder>.from(constructorReferences), |
| startOffset, |
| nameOffset, |
| endOffset, |
| referencesFromClass, |
| _currentClassReferencesFromIndexed, |
| isMixinDeclaration: isMixinDeclaration); |
| loader.target.metadataCollector |
| ?.setDocumentationComment(classBuilder.cls, documentationComment); |
| |
| constructorReferences.clear(); |
| Map<String, TypeVariableBuilder> typeVariablesByName = |
| checkTypeVariables(typeVariables, classBuilder); |
| void setParent(String name, MemberBuilder member) { |
| while (member != null) { |
| member.parent = classBuilder; |
| member = member.next; |
| } |
| } |
| |
| void setParentAndCheckConflicts(String name, MemberBuilder member) { |
| if (typeVariablesByName != null) { |
| TypeVariableBuilder tv = typeVariablesByName[name]; |
| if (tv != null) { |
| classBuilder.addProblem( |
| templateConflictsWithTypeVariable.withArguments(name), |
| member.charOffset, |
| name.length, |
| context: [ |
| messageConflictsWithTypeVariableCause.withLocation( |
| tv.fileUri, tv.charOffset, name.length) |
| ]); |
| } |
| } |
| setParent(name, member); |
| } |
| |
| members.forEach(setParentAndCheckConflicts); |
| constructors.forEach(setParentAndCheckConflicts); |
| setters.forEach(setParentAndCheckConflicts); |
| addBuilder(className, classBuilder, nameOffset, |
| getterReference: referencesFromClass?.reference); |
| } |
| |
| Map<String, TypeVariableBuilder> checkTypeVariables( |
| List<TypeVariableBuilder> typeVariables, Builder owner) { |
| if (typeVariables?.isEmpty ?? true) return null; |
| Map<String, TypeVariableBuilder> typeVariablesByName = |
| <String, TypeVariableBuilder>{}; |
| for (TypeVariableBuilder tv in typeVariables) { |
| TypeVariableBuilder existing = typeVariablesByName[tv.name]; |
| if (existing != null) { |
| if (existing.isExtensionTypeParameter) { |
| // The type parameter from the extension is shadowed by the type |
| // parameter from the member. Rename the shadowed type parameter. |
| existing.parameter.name = '#${existing.name}'; |
| typeVariablesByName[tv.name] = tv; |
| } else { |
| addProblem(messageTypeVariableDuplicatedName, tv.charOffset, |
| tv.name.length, fileUri, |
| context: [ |
| templateTypeVariableDuplicatedNameCause |
| .withArguments(tv.name) |
| .withLocation( |
| fileUri, existing.charOffset, existing.name.length) |
| ]); |
| } |
| } else { |
| typeVariablesByName[tv.name] = tv; |
| if (owner is ClassBuilder) { |
| // Only classes and type variables can't have the same name. See |
| // [#29555](https://github.com/dart-lang/sdk/issues/29555). |
| if (tv.name == owner.name) { |
| addProblem(messageTypeVariableSameNameAsEnclosing, tv.charOffset, |
| tv.name.length, fileUri); |
| } |
| } |
| } |
| } |
| return typeVariablesByName; |
| } |
| |
| void checkGetterSetterTypes(ProcedureBuilder getterBuilder, |
| ProcedureBuilder setterBuilder, TypeEnvironment typeEnvironment) { |
| DartType getterType; |
| List<TypeParameter> getterExtensionTypeParameters; |
| if (getterBuilder.isExtensionInstanceMember) { |
| // An extension instance getter |
| // |
| // extension E<T> on A { |
| // T get property => ... |
| // } |
| // |
| // is encoded as a top level method |
| // |
| // T# E#get#property<T#>(A #this) => ... |
| // |
| Procedure procedure = getterBuilder.procedure; |
| getterType = procedure.function.returnType; |
| getterExtensionTypeParameters = procedure.function.typeParameters; |
| } else { |
| getterType = getterBuilder.procedure.getterType; |
| } |
| DartType setterType; |
| if (setterBuilder.isExtensionInstanceMember) { |
| // An extension instance setter |
| // |
| // extension E<T> on A { |
| // void set property(T value) { ... } |
| // } |
| // |
| // is encoded as a top level method |
| // |
| // void E#set#property<T#>(A #this, T# value) { ... } |
| // |
| Procedure procedure = setterBuilder.procedure; |
| setterType = procedure.function.positionalParameters[1].type; |
| if (getterExtensionTypeParameters != null && |
| getterExtensionTypeParameters.isNotEmpty) { |
| // We substitute the setter type parameters for the getter type |
| // parameters to check them below in a shared context. |
| List<TypeParameter> setterExtensionTypeParameters = |
| procedure.function.typeParameters; |
| assert(getterExtensionTypeParameters.length == |
| setterExtensionTypeParameters.length); |
| setterType = Substitution.fromPairs( |
| setterExtensionTypeParameters, |
| new List<DartType>.generate( |
| getterExtensionTypeParameters.length, |
| (int index) => new TypeParameterType.forAlphaRenaming( |
| setterExtensionTypeParameters[index], |
| getterExtensionTypeParameters[index]))) |
| .substituteType(setterType); |
| } |
| } else { |
| setterType = setterBuilder.procedure.setterType; |
| } |
| |
| if (getterType is InvalidType || setterType is InvalidType) { |
| // Don't report a problem as something else is wrong that has already |
| // been reported. |
| } else { |
| bool isValid = typeEnvironment.isSubtypeOf( |
| getterType, |
| setterType, |
| library.isNonNullableByDefault |
| ? SubtypeCheckMode.withNullabilities |
| : SubtypeCheckMode.ignoringNullabilities); |
| if (!isValid && !library.isNonNullableByDefault) { |
| // Allow assignability in legacy libraries. |
| isValid = typeEnvironment.isSubtypeOf( |
| setterType, getterType, SubtypeCheckMode.ignoringNullabilities); |
| } |
| if (!isValid) { |
| String getterMemberName = getterBuilder.fullNameForErrors; |
| String setterMemberName = setterBuilder.fullNameForErrors; |
| Template<Message Function(DartType, String, DartType, String, bool)> |
| template = library.isNonNullableByDefault |
| ? templateInvalidGetterSetterType |
| : templateInvalidGetterSetterTypeLegacy; |
| addProblem( |
| template.withArguments(getterType, getterMemberName, setterType, |
| setterMemberName, library.isNonNullableByDefault), |
| getterBuilder.charOffset, |
| getterBuilder.name.length, |
| getterBuilder.fileUri, |
| context: [ |
| templateInvalidGetterSetterTypeSetterContext |
| .withArguments(setterMemberName) |
| .withLocation(setterBuilder.fileUri, setterBuilder.charOffset, |
| setterBuilder.name.length) |
| ]); |
| } |
| } |
| } |
| |
| void addExtensionDeclaration( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| int modifiers, |
| String extensionName, |
| List<TypeVariableBuilder> typeVariables, |
| TypeBuilder type, |
| int startOffset, |
| int nameOffset, |
| int endOffset) { |
| // Nested declaration began in `OutlineBuilder.beginExtensionDeclaration`. |
| TypeParameterScopeBuilder declaration = endNestedDeclaration( |
| TypeParameterScopeKind.extensionDeclaration, extensionName) |
| ..resolveTypes(typeVariables, this); |
| assert(declaration.parent == libraryDeclaration); |
| Map<String, MemberBuilder> members = declaration.members; |
| Map<String, MemberBuilder> constructors = declaration.constructors; |
| Map<String, MemberBuilder> setters = declaration.setters; |
| |
| Scope classScope = new Scope( |
| local: members, |
| setters: setters, |
| parent: scope.withTypeVariables(typeVariables), |
| debugName: "extension $extensionName", |
| isModifiable: false); |
| |
| Extension referenceFrom = |
| referencesFromIndexed?.lookupExtension(extensionName); |
| |
| ExtensionBuilder extensionBuilder = new SourceExtensionBuilder( |
| metadata, |
| modifiers, |
| extensionName, |
| typeVariables, |
| type, |
| classScope, |
| this, |
| startOffset, |
| nameOffset, |
| endOffset, |
| referenceFrom); |
| loader.target.metadataCollector?.setDocumentationComment( |
| extensionBuilder.extension, documentationComment); |
| |
| constructorReferences.clear(); |
| Map<String, TypeVariableBuilder> typeVariablesByName = |
| checkTypeVariables(typeVariables, extensionBuilder); |
| void setParent(String name, MemberBuilder member) { |
| while (member != null) { |
| member.parent = extensionBuilder; |
| member = member.next; |
| } |
| } |
| |
| void setParentAndCheckConflicts(String name, MemberBuilder member) { |
| if (typeVariablesByName != null) { |
| TypeVariableBuilder tv = typeVariablesByName[name]; |
| if (tv != null) { |
| extensionBuilder.addProblem( |
| templateConflictsWithTypeVariable.withArguments(name), |
| member.charOffset, |
| name.length, |
| context: [ |
| messageConflictsWithTypeVariableCause.withLocation( |
| tv.fileUri, tv.charOffset, name.length) |
| ]); |
| } |
| } |
| setParent(name, member); |
| } |
| |
| members.forEach(setParentAndCheckConflicts); |
| constructors.forEach(setParentAndCheckConflicts); |
| setters.forEach(setParentAndCheckConflicts); |
| addBuilder(extensionName, extensionBuilder, nameOffset, |
| getterReference: referenceFrom?.reference); |
| } |
| |
| TypeBuilder applyMixins(TypeBuilder type, int startCharOffset, int charOffset, |
| int charEndOffset, String subclassName, bool isMixinDeclaration, |
| {String documentationComment, |
| List<MetadataBuilder> metadata, |
| String name, |
| List<TypeVariableBuilder> typeVariables, |
| int modifiers, |
| List<TypeBuilder> interfaces}) { |
| if (name == null) { |
| // The following parameters should only be used when building a named |
| // mixin application. |
| if (documentationComment != null) { |
| unhandled("documentationComment", "unnamed mixin application", |
| charOffset, fileUri); |
| } else if (metadata != null) { |
| unhandled("metadata", "unnamed mixin application", charOffset, fileUri); |
| } else if (interfaces != null) { |
| unhandled( |
| "interfaces", "unnamed mixin application", charOffset, fileUri); |
| } |
| } |
| if (type is MixinApplicationBuilder) { |
| // Documentation below assumes the given mixin application is in one of |
| // these forms: |
| // |
| // class C extends S with M1, M2, M3; |
| // class Named = S with M1, M2, M3; |
| // |
| // When we refer to the subclass, we mean `C` or `Named`. |
| |
| /// The current supertype. |
| /// |
| /// Starts out having the value `S` and on each iteration of the loop |
| /// below, it will take on the value corresponding to: |
| /// |
| /// 1. `S with M1`. |
| /// 2. `(S with M1) with M2`. |
| /// 3. `((S with M1) with M2) with M3`. |
| TypeBuilder supertype = type.supertype ?? loader.target.objectType; |
| |
| /// The variable part of the mixin application's synthetic name. It |
| /// starts out as the name of the superclass, but is only used after it |
| /// has been combined with the name of the current mixin. In the examples |
| /// from above, it will take these values: |
| /// |
| /// 1. `S&M1` |
| /// 2. `S&M1&M2` |
| /// 3. `S&M1&M2&M3`. |
| /// |
| /// The full name of the mixin application is obtained by prepending the |
| /// name of the subclass (`C` or `Named` in the above examples) to the |
| /// running name. For the example `C`, that leads to these full names: |
| /// |
| /// 1. `_C&S&M1` |
| /// 2. `_C&S&M1&M2` |
| /// 3. `_C&S&M1&M2&M3`. |
| /// |
| /// For a named mixin application, the last name has been given by the |
| /// programmer, so for the example `Named` we see these full names: |
| /// |
| /// 1. `_Named&S&M1` |
| /// 2. `_Named&S&M1&M2` |
| /// 3. `Named`. |
| String runningName = extractName(supertype.name); |
| |
| /// True when we're building a named mixin application. Notice that for |
| /// the `Named` example above, this is only true on the last |
| /// iteration because only the full mixin application is named. |
| bool isNamedMixinApplication; |
| |
| /// The names of the type variables of the subclass. |
| Set<String> typeVariableNames; |
| if (typeVariables != null) { |
| typeVariableNames = new Set<String>(); |
| for (TypeVariableBuilder typeVariable in typeVariables) { |
| typeVariableNames.add(typeVariable.name); |
| } |
| } |
| |
| /// Helper function that returns `true` if a type variable with a name |
| /// from [typeVariableNames] is referenced in [type]. |
| bool usesTypeVariables(TypeBuilder type) { |
| if (type is NamedTypeBuilder) { |
| if (type.declaration is TypeVariableBuilder) { |
| return typeVariableNames.contains(type.declaration.name); |
| } |
| |
| List<TypeBuilder> typeArguments = type.arguments; |
| if (typeArguments != null && typeVariables != null) { |
| for (TypeBuilder argument in typeArguments) { |
| if (usesTypeVariables(argument)) { |
| return true; |
| } |
| } |
| } |
| } else if (type is FunctionTypeBuilder) { |
| if (type.formals != null) { |
| for (FormalParameterBuilder formal in type.formals) { |
| if (usesTypeVariables(formal.type)) { |
| return true; |
| } |
| } |
| } |
| List<TypeVariableBuilder> typeVariables = type.typeVariables; |
| if (typeVariables != null) { |
| for (TypeVariableBuilder variable in typeVariables) { |
| if (usesTypeVariables(variable.bound)) { |
| return true; |
| } |
| } |
| } |
| return usesTypeVariables(type.returnType); |
| } |
| return false; |
| } |
| |
| /// Iterate over the mixins from left to right. At the end of each |
| /// iteration, a new [supertype] is computed that is the mixin |
| /// application of [supertype] with the current mixin. |
| for (int i = 0; i < type.mixins.length; i++) { |
| TypeBuilder mixin = type.mixins[i]; |
| isNamedMixinApplication = name != null && mixin == type.mixins.last; |
| bool isGeneric = false; |
| if (!isNamedMixinApplication) { |
| if (supertype is NamedTypeBuilder) { |
| isGeneric = isGeneric || usesTypeVariables(supertype); |
| } |
| if (mixin is NamedTypeBuilder) { |
| runningName += "&${extractName(mixin.name)}"; |
| isGeneric = isGeneric || usesTypeVariables(mixin); |
| } |
| } |
| String fullname = |
| isNamedMixinApplication ? name : "_$subclassName&$runningName"; |
| List<TypeVariableBuilder> applicationTypeVariables; |
| List<TypeBuilder> applicationTypeArguments; |
| if (isNamedMixinApplication) { |
| // If this is a named mixin application, it must be given all the |
| // declarated type variables. |
| applicationTypeVariables = typeVariables; |
| } else { |
| // Otherwise, we pass the fresh type variables to the mixin |
| // application in the same order as they're declared on the subclass. |
| if (isGeneric) { |
| this.beginNestedDeclaration( |
| TypeParameterScopeKind.unnamedMixinApplication, |
| "mixin application"); |
| |
| applicationTypeVariables = copyTypeVariables( |
| typeVariables, currentTypeParameterScopeBuilder); |
| |
| List<TypeBuilder> newTypes = <TypeBuilder>[]; |
| if (supertype is NamedTypeBuilder && supertype.arguments != null) { |
| for (int i = 0; i < supertype.arguments.length; ++i) { |
| supertype.arguments[i] = supertype.arguments[i].clone(newTypes); |
| } |
| } |
| if (mixin is NamedTypeBuilder && mixin.arguments != null) { |
| for (int i = 0; i < mixin.arguments.length; ++i) { |
| mixin.arguments[i] = mixin.arguments[i].clone(newTypes); |
| } |
| } |
| for (TypeBuilder newType in newTypes) { |
| currentTypeParameterScopeBuilder |
| .addType(new UnresolvedType(newType, -1, null)); |
| } |
| |
| TypeParameterScopeBuilder mixinDeclaration = this |
| .endNestedDeclaration( |
| TypeParameterScopeKind.unnamedMixinApplication, |
| "mixin application"); |
| mixinDeclaration.resolveTypes(applicationTypeVariables, this); |
| |
| applicationTypeArguments = <TypeBuilder>[]; |
| for (TypeVariableBuilder typeVariable in typeVariables) { |
| applicationTypeArguments.add(addNamedType(typeVariable.name, |
| const NullabilityBuilder.omitted(), null, charOffset) |
| ..bind( |
| // The type variable types passed as arguments to the |
| // generic class representing the anonymous mixin |
| // application should refer back to the type variables of |
| // the class that extend the anonymous mixin application. |
| typeVariable)); |
| } |
| } |
| } |
| final int computedStartCharOffset = |
| (isNamedMixinApplication ? metadata : null) == null |
| ? startCharOffset |
| : metadata.first.charOffset; |
| |
| Class referencesFromClass; |
| IndexedClass referencesFromIndexedClass; |
| if (referencesFrom != null) { |
| referencesFromClass = referencesFromIndexed.lookupClass(fullname); |
| referencesFromIndexedClass = |
| referencesFromIndexed.lookupIndexedClass(fullname); |
| } |
| |
| SourceClassBuilder application = new SourceClassBuilder( |
| isNamedMixinApplication ? metadata : null, |
| isNamedMixinApplication |
| ? modifiers | namedMixinApplicationMask |
| : abstractMask, |
| fullname, |
| applicationTypeVariables, |
| isMixinDeclaration ? null : supertype, |
| isNamedMixinApplication |
| ? interfaces |
| : isMixinDeclaration |
| ? [supertype, mixin] |
| : null, |
| null, // No `on` clause types. |
| new Scope( |
| local: <String, MemberBuilder>{}, |
| setters: <String, MemberBuilder>{}, |
| parent: scope.withTypeVariables(typeVariables), |
| debugName: "mixin $fullname ", |
| isModifiable: false), |
| new ConstructorScope(fullname, <String, MemberBuilder>{}), |
| this, |
| <ConstructorReferenceBuilder>[], |
| computedStartCharOffset, |
| charOffset, |
| charEndOffset, |
| referencesFromClass, |
| referencesFromIndexedClass, |
| mixedInTypeBuilder: isMixinDeclaration ? null : mixin, |
| ); |
| if (isNamedMixinApplication) { |
| loader.target.metadataCollector |
| ?.setDocumentationComment(application.cls, documentationComment); |
| } |
| // TODO(ahe, kmillikin): Should always be true? |
| // pkg/analyzer/test/src/summary/resynthesize_kernel_test.dart can't |
| // handle that :( |
| application.cls.isAnonymousMixin = !isNamedMixinApplication; |
| addBuilder(fullname, application, charOffset, |
| getterReference: referencesFromClass?.reference); |
| supertype = addNamedType(fullname, const NullabilityBuilder.omitted(), |
| applicationTypeArguments, charOffset); |
| } |
| return supertype; |
| } else { |
| return type; |
| } |
| } |
| |
| void addNamedMixinApplication( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| String name, |
| List<TypeVariableBuilder> typeVariables, |
| int modifiers, |
| TypeBuilder mixinApplication, |
| List<TypeBuilder> interfaces, |
| int startCharOffset, |
| int charOffset, |
| int charEndOffset) { |
| // Nested declaration began in `OutlineBuilder.beginNamedMixinApplication`. |
| endNestedDeclaration(TypeParameterScopeKind.namedMixinApplication, name) |
| .resolveTypes(typeVariables, this); |
| NamedTypeBuilder supertype = applyMixins(mixinApplication, startCharOffset, |
| charOffset, charEndOffset, name, false, |
| documentationComment: documentationComment, |
| metadata: metadata, |
| name: name, |
| typeVariables: typeVariables, |
| modifiers: modifiers, |
| interfaces: interfaces); |
| checkTypeVariables(typeVariables, supertype.declaration); |
| } |
| |
| void addField( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| int modifiers, |
| bool isTopLevel, |
| TypeBuilder type, |
| String name, |
| int charOffset, |
| int charEndOffset, |
| Token initializerToken, |
| bool hasInitializer, |
| {Token constInitializerToken}) { |
| if (hasInitializer) { |
| modifiers |= hasInitializerMask; |
| } |
| Field referenceFrom; |
| Field lateIsSetReferenceFrom; |
| Procedure getterReferenceFrom; |
| Procedure setterReferenceFrom; |
| final bool fieldIsLateWithLowering = (modifiers & lateMask) != 0 && |
| !loader.target.backendTarget.supportsLateFields; |
| final bool isInstanceMember = currentTypeParameterScopeBuilder.kind == |
| TypeParameterScopeKind.classDeclaration && |
| (modifiers & staticMask) == 0; |
| String className; |
| if (isInstanceMember) { |
| className = currentTypeParameterScopeBuilder.name; |
| } |
| final bool isExtension = currentTypeParameterScopeBuilder.kind == |
| TypeParameterScopeKind.extensionDeclaration; |
| String extensionName; |
| if (isExtension) { |
| extensionName = currentTypeParameterScopeBuilder.name; |
| } |
| if (referencesFrom != null) { |
| String nameToLookup = SourceFieldBuilder.createFieldName( |
| FieldNameType.Field, name, |
| isInstanceMember: isInstanceMember, |
| className: className, |
| isExtensionMethod: isExtension, |
| extensionName: extensionName, |
| isSynthesized: fieldIsLateWithLowering); |
| |
| if (_currentClassReferencesFromIndexed != null) { |
| referenceFrom = |
| _currentClassReferencesFromIndexed.lookupField(nameToLookup); |
| if (fieldIsLateWithLowering) { |
| lateIsSetReferenceFrom = _currentClassReferencesFromIndexed |
| .lookupField(SourceFieldBuilder.createFieldName( |
| FieldNameType.IsSetField, name, |
| isInstanceMember: isInstanceMember, |
| className: className, |
| isExtensionMethod: isExtension, |
| extensionName: extensionName, |
| isSynthesized: fieldIsLateWithLowering)); |
| getterReferenceFrom = |
| _currentClassReferencesFromIndexed.lookupProcedureNotSetter( |
| SourceFieldBuilder.createFieldName(FieldNameType.Getter, name, |
| isInstanceMember: isInstanceMember, |
| className: className, |
| isExtensionMethod: isExtension, |
| extensionName: extensionName, |
| isSynthesized: fieldIsLateWithLowering)); |
| setterReferenceFrom = |
| _currentClassReferencesFromIndexed.lookupProcedureSetter( |
| SourceFieldBuilder.createFieldName(FieldNameType.Setter, name, |
| isInstanceMember: isInstanceMember, |
| className: className, |
| isExtensionMethod: isExtension, |
| extensionName: extensionName, |
| isSynthesized: fieldIsLateWithLowering)); |
| } |
| } else { |
| referenceFrom = referencesFromIndexed.lookupField(nameToLookup); |
| if (fieldIsLateWithLowering) { |
| lateIsSetReferenceFrom = referencesFromIndexed.lookupField( |
| SourceFieldBuilder.createFieldName(FieldNameType.IsSetField, name, |
| isInstanceMember: isInstanceMember, |
| className: className, |
| isExtensionMethod: isExtension, |
| extensionName: extensionName, |
| isSynthesized: fieldIsLateWithLowering)); |
| getterReferenceFrom = referencesFromIndexed.lookupProcedureNotSetter( |
| SourceFieldBuilder.createFieldName(FieldNameType.Getter, name, |
| isInstanceMember: isInstanceMember, |
| className: className, |
| isExtensionMethod: isExtension, |
| extensionName: extensionName, |
| isSynthesized: fieldIsLateWithLowering)); |
| setterReferenceFrom = referencesFromIndexed.lookupProcedureSetter( |
| SourceFieldBuilder.createFieldName(FieldNameType.Setter, name, |
| isInstanceMember: isInstanceMember, |
| className: className, |
| isExtensionMethod: isExtension, |
| extensionName: extensionName, |
| isSynthesized: fieldIsLateWithLowering)); |
| } |
| } |
| } |
| SourceFieldBuilder fieldBuilder = new SourceFieldBuilder( |
| metadata, |
| type, |
| name, |
| modifiers, |
| isTopLevel, |
| this, |
| charOffset, |
| charEndOffset, |
| referenceFrom, |
| lateIsSetReferenceFrom, |
| getterReferenceFrom, |
| setterReferenceFrom); |
| fieldBuilder.constInitializerToken = constInitializerToken; |
| addBuilder(name, fieldBuilder, charOffset, |
| getterReference: referenceFrom?.getterReference, |
| setterReference: referenceFrom?.setterReference); |
| if (type == null && fieldBuilder.next == null) { |
| // Only the first one (the last one in the linked list of next pointers) |
| // are added to the tree, had parent pointers and can infer correctly. |
| if (initializerToken == null && fieldBuilder.isStatic) { |
| // A static field without type and initializer will always be inferred |
| // to have type `dynamic`. |
| fieldBuilder.fieldType = const DynamicType(); |
| } else { |
| // A field with no type and initializer or an instance field without |
| // type and initializer need to have the type inferred. |
| fieldBuilder.fieldType = |
| new ImplicitFieldType(fieldBuilder, initializerToken); |
| registerImplicitlyTypedField(fieldBuilder); |
| } |
| } |
| loader.target.metadataCollector |
| ?.setDocumentationComment(fieldBuilder.field, documentationComment); |
| } |
| |
| void addConstructor( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| int modifiers, |
| TypeBuilder returnType, |
| final Object name, |
| String constructorName, |
| List<TypeVariableBuilder> typeVariables, |
| List<FormalParameterBuilder> formals, |
| int startCharOffset, |
| int charOffset, |
| int charOpenParenOffset, |
| int charEndOffset, |
| String nativeMethodName, |
| {Token beginInitializers}) { |
| MetadataCollector metadataCollector = loader.target.metadataCollector; |
| Constructor referenceFrom; |
| if (_currentClassReferencesFromIndexed != null) { |
| referenceFrom = |
| _currentClassReferencesFromIndexed.lookupConstructor(constructorName); |
| } |
| ConstructorBuilder constructorBuilder = new ConstructorBuilderImpl( |
| metadata, |
| modifiers & ~abstractMask, |
| returnType, |
| constructorName, |
| typeVariables, |
| formals, |
| this, |
| startCharOffset, |
| charOffset, |
| charOpenParenOffset, |
| charEndOffset, |
| referenceFrom, |
| nativeMethodName); |
| metadataCollector?.setDocumentationComment( |
| constructorBuilder.constructor, documentationComment); |
| metadataCollector?.setConstructorNameOffset( |
| constructorBuilder.constructor, name); |
| checkTypeVariables(typeVariables, constructorBuilder); |
| addBuilder(constructorName, constructorBuilder, charOffset, |
| getterReference: referenceFrom?.reference); |
| if (nativeMethodName != null) { |
| addNativeMethod(constructorBuilder); |
| } |
| if (constructorBuilder.isConst) { |
| currentTypeParameterScopeBuilder?.declaresConstConstructor = true; |
| // const constructors will have their initializers compiled and written |
| // into the outline. |
| constructorBuilder.beginInitializers = |
| beginInitializers ?? new Token.eof(-1); |
| } |
| } |
| |
| void addProcedure( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| int modifiers, |
| TypeBuilder returnType, |
| String name, |
| List<TypeVariableBuilder> typeVariables, |
| List<FormalParameterBuilder> formals, |
| ProcedureKind kind, |
| int startCharOffset, |
| int charOffset, |
| int charOpenParenOffset, |
| int charEndOffset, |
| String nativeMethodName, |
| AsyncMarker asyncModifier, |
| {bool isTopLevel, |
| bool isExtensionInstanceMember}) { |
| assert(isTopLevel != null); |
| assert(isExtensionInstanceMember != null); |
| |
| MetadataCollector metadataCollector = loader.target.metadataCollector; |
| if (returnType == null) { |
| if (kind == ProcedureKind.Operator && |
| identical(name, indexSetName.text)) { |
| returnType = addVoidType(charOffset); |
| } else if (kind == ProcedureKind.Setter) { |
| returnType = addVoidType(charOffset); |
| } |
| } |
| Procedure referenceFrom; |
| Procedure tearOffReferenceFrom; |
| if (referencesFrom != null) { |
| if (_currentClassReferencesFromIndexed != null) { |
| if (kind == ProcedureKind.Setter) { |
| referenceFrom = |
| _currentClassReferencesFromIndexed.lookupProcedureSetter(name); |
| } else { |
| referenceFrom = |
| _currentClassReferencesFromIndexed.lookupProcedureNotSetter(name); |
| } |
| } else { |
| if (currentTypeParameterScopeBuilder.kind == |
| TypeParameterScopeKind.extensionDeclaration) { |
| bool extensionIsStatic = (modifiers & staticMask) != 0; |
| String nameToLookup = SourceProcedureBuilder.createProcedureName( |
| true, |
| extensionIsStatic, |
| kind, |
| currentTypeParameterScopeBuilder.name, |
| name); |
| if (extensionIsStatic && kind == ProcedureKind.Setter) { |
| referenceFrom = |
| referencesFromIndexed.lookupProcedureSetter(nameToLookup); |
| } else { |
| referenceFrom = |
| referencesFromIndexed.lookupProcedureNotSetter(nameToLookup); |
| } |
| if (kind == ProcedureKind.Method) { |
| String tearOffNameToLookup = |
| SourceProcedureBuilder.createProcedureName( |
| true, |
| false, |
| ProcedureKind.Getter, |
| currentTypeParameterScopeBuilder.name, |
| name); |
| tearOffReferenceFrom = referencesFromIndexed |
| .lookupProcedureNotSetter(tearOffNameToLookup); |
| } |
| } else { |
| if (kind == ProcedureKind.Setter) { |
| referenceFrom = referencesFromIndexed.lookupProcedureSetter(name); |
| } else { |
| referenceFrom = |
| referencesFromIndexed.lookupProcedureNotSetter(name); |
| } |
| } |
| } |
| } |
| ProcedureBuilder procedureBuilder = new SourceProcedureBuilder( |
| metadata, |
| modifiers, |
| returnType, |
| name, |
| typeVariables, |
| formals, |
| kind, |
| this, |
| startCharOffset, |
| charOffset, |
| charOpenParenOffset, |
| charEndOffset, |
| referenceFrom, |
| tearOffReferenceFrom, |
| asyncModifier, |
| isExtensionInstanceMember, |
| nativeMethodName); |
| metadataCollector?.setDocumentationComment( |
| procedureBuilder.procedure, documentationComment); |
| checkTypeVariables(typeVariables, procedureBuilder); |
| addBuilder(name, procedureBuilder, charOffset, |
| getterReference: referenceFrom?.reference); |
| if (nativeMethodName != null) { |
| addNativeMethod(procedureBuilder); |
| } |
| } |
| |
| void addFactoryMethod( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| int modifiers, |
| Object name, |
| List<FormalParameterBuilder> formals, |
| ConstructorReferenceBuilder redirectionTarget, |
| int startCharOffset, |
| int charOffset, |
| int charOpenParenOffset, |
| int charEndOffset, |
| String nativeMethodName, |
| AsyncMarker asyncModifier) { |
| TypeBuilder returnType = addNamedType( |
| currentTypeParameterScopeBuilder.parent.name, |
| const NullabilityBuilder.omitted(), |
| <TypeBuilder>[], |
| charOffset); |
| // Nested declaration began in `OutlineBuilder.beginFactoryMethod`. |
| TypeParameterScopeBuilder factoryDeclaration = endNestedDeclaration( |
| TypeParameterScopeKind.factoryMethod, "#factory_method"); |
| |
| // Prepare the simple procedure name. |
| String procedureName; |
| String constructorName = |
| computeAndValidateConstructorName(name, charOffset, isFactory: true); |
| if (constructorName != null) { |
| procedureName = constructorName; |
| } else { |
| procedureName = name; |
| } |
| |
| Procedure referenceFrom = _currentClassReferencesFromIndexed |
| ?.lookupProcedureNotSetter(procedureName); |
| |
| ProcedureBuilder procedureBuilder; |
| if (redirectionTarget != null) { |
| procedureBuilder = new RedirectingFactoryBuilder( |
| metadata, |
| staticMask | modifiers, |
| returnType, |
| procedureName, |
| copyTypeVariables( |
| currentTypeParameterScopeBuilder.typeVariables ?? |
| const <TypeVariableBuilder>[], |
| factoryDeclaration), |
| formals, |
| this, |
| startCharOffset, |
| charOffset, |
| charOpenParenOffset, |
| charEndOffset, |
| referenceFrom, |
| nativeMethodName, |
| redirectionTarget); |
| } else { |
| procedureBuilder = new SourceProcedureBuilder( |
| metadata, |
| staticMask | modifiers, |
| returnType, |
| procedureName, |
| copyTypeVariables( |
| currentTypeParameterScopeBuilder.typeVariables ?? |
| const <TypeVariableBuilder>[], |
| factoryDeclaration), |
| formals, |
| ProcedureKind.Factory, |
| this, |
| startCharOffset, |
| charOffset, |
| charOpenParenOffset, |
| charEndOffset, |
| referenceFrom, |
| null, |
| asyncModifier, |
| /* isExtensionInstanceMember = */ false, |
| nativeMethodName); |
| } |
| |
| MetadataCollector metadataCollector = loader.target.metadataCollector; |
| metadataCollector?.setDocumentationComment( |
| procedureBuilder.procedure, documentationComment); |
| metadataCollector?.setConstructorNameOffset( |
| procedureBuilder.procedure, name); |
| |
| TypeParameterScopeBuilder savedDeclaration = |
| currentTypeParameterScopeBuilder; |
| currentTypeParameterScopeBuilder = factoryDeclaration; |
| for (TypeVariableBuilder tv in procedureBuilder.typeVariables) { |
| NamedTypeBuilder t = procedureBuilder.returnType; |
| t.arguments.add(addNamedType(tv.name, const NullabilityBuilder.omitted(), |
| null, procedureBuilder.charOffset)); |
| } |
| currentTypeParameterScopeBuilder = savedDeclaration; |
| |
| factoryDeclaration.resolveTypes(procedureBuilder.typeVariables, this); |
| addBuilder(procedureName, procedureBuilder, charOffset, |
| getterReference: referenceFrom?.reference); |
| if (nativeMethodName != null) { |
| addNativeMethod(procedureBuilder); |
| } |
| } |
| |
| void addEnum( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| String name, |
| List<EnumConstantInfo> enumConstantInfos, |
| int startCharOffset, |
| int charOffset, |
| int charEndOffset) { |
| MetadataCollector metadataCollector = loader.target.metadataCollector; |
| Class referencesFromClass; |
| IndexedClass referencesFromIndexedClass; |
| if (referencesFrom != null) { |
| referencesFromClass = referencesFromIndexed.lookupClass(name); |
| referencesFromIndexedClass = |
| referencesFromIndexed.lookupIndexedClass(name); |
| } |
| EnumBuilder builder = new EnumBuilder( |
| metadataCollector, |
| metadata, |
| name, |
| enumConstantInfos, |
| this, |
| startCharOffset, |
| charOffset, |
| charEndOffset, |
| referencesFromClass, |
| referencesFromIndexedClass); |
| addBuilder(name, builder, charOffset, |
| getterReference: referencesFromClass?.reference); |
| metadataCollector?.setDocumentationComment( |
| builder.cls, documentationComment); |
| } |
| |
| void addFunctionTypeAlias( |
| String documentationComment, |
| List<MetadataBuilder> metadata, |
| String name, |
| List<TypeVariableBuilder> typeVariables, |
| TypeBuilder type, |
| int charOffset) { |
| if (typeVariables != null) { |
| for (TypeVariableBuilder typeVariable in typeVariables) { |
| typeVariable.variance = pendingVariance; |
| } |
| } |
| Typedef referenceFrom = referencesFromIndexed?.lookupTypedef(name); |
| TypeAliasBuilder typedefBuilder = new SourceTypeAliasBuilder( |
| metadata, name, typeVariables, type, this, charOffset, |
| referenceFrom: referenceFrom); |
| loader.target.metadataCollector |
| ?.setDocumentationComment(typedefBuilder.typedef, documentationComment); |
| checkTypeVariables(typeVariables, typedefBuilder); |
| // Nested declaration began in `OutlineBuilder.beginFunctionTypeAlias`. |
| endNestedDeclaration(TypeParameterScopeKind.typedef, "#typedef") |
| .resolveTypes(typeVariables, this); |
| addBuilder(name, typedefBuilder, charOffset, |
| getterReference: referenceFrom?.reference); |
| } |
| |
| FunctionTypeBuilder addFunctionType( |
| TypeBuilder returnType, |
| List<TypeVariableBuilder> typeVariables, |
| List<FormalParameterBuilder> formals, |
| NullabilityBuilder nullabilityBuilder, |
| int charOffset) { |
| FunctionTypeBuilder builder = new FunctionTypeBuilder(returnType, |
| typeVariables, formals, nullabilityBuilder, fileUri, charOffset); |
| checkTypeVariables(typeVariables, null); |
| // Nested declaration began in `OutlineBuilder.beginFunctionType` or |
| // `OutlineBuilder.beginFunctionTypedFormalParameter`. |
| endNestedDeclaration(TypeParameterScopeKind.functionType, "#function_type") |
| .resolveTypes(typeVariables, this); |
| return addType(builder, charOffset); |
| } |
| |
| FormalParameterBuilder addFormalParameter( |
| List<MetadataBuilder> metadata, |
| int modifiers, |
| TypeBuilder type, |
| String name, |
| bool hasThis, |
| int charOffset, |
| Token initializerToken) { |
| if (hasThis) { |
| modifiers |= initializingFormalMask; |
| } |
| FormalParameterBuilder formal = new FormalParameterBuilder( |
| metadata, modifiers, type, name, this, charOffset, fileUri) |
| ..initializerToken = initializerToken |
| ..hasDeclaredInitializer = (initializerToken != null); |
| return formal; |
| } |
| |
| TypeVariableBuilder addTypeVariable( |
| String name, TypeBuilder bound, int charOffset) { |
| TypeVariableBuilder builder = |
| new TypeVariableBuilder(name, this, charOffset, bound: bound); |
| boundlessTypeVariables.add(builder); |
| return builder; |
| } |
| |
| @override |
| void buildOutlineExpressions() { |
| MetadataBuilder.buildAnnotations(library, metadata, this, null, null); |
| } |
| |
| /// Builds the core AST structures for [declaration] needed for the outline. |
| void buildBuilder(Builder declaration, LibraryBuilder coreLibrary) { |
| String findDuplicateSuffix(Builder declaration) { |
| if (declaration.next != null) { |
| int count = 0; |
| Builder current = declaration.next; |
| while (current != null) { |
| count++; |
| current = current.next; |
| } |
| return "#$count"; |
| } |
| return ""; |
| } |
| |
| if (declaration is SourceClassBuilder) { |
| Class cls = declaration.build(this, coreLibrary); |
| if (!declaration.isPatch) { |
| cls.name += findDuplicateSuffix(declaration); |
| library.addClass(cls); |
| } |
| } else if (declaration is SourceExtensionBuilder) { |
| Extension extension = declaration.build(this, coreLibrary, |
| addMembersToLibrary: !declaration.isDuplicate); |
| if (!declaration.isPatch && !declaration.isDuplicate) { |
| library.addExtension(extension); |
| } |
| } else if (declaration is MemberBuilderImpl) { |
| declaration.buildMembers(this, |
| (Member member, BuiltMemberKind memberKind) { |
| if (member is Field) { |
| member.isStatic = true; |
| if (!declaration.isPatch && !declaration.isDuplicate) { |
| library.addField(member); |
| } |
| } else if (member is Procedure) { |
| member.isStatic = true; |
| if (!declaration.isPatch && !declaration.isDuplicate) { |
| library.addProcedure(member); |
| } |
| } else { |
| unhandled("${member.runtimeType}:${memberKind}", "buildBuilder", |
| declaration.charOffset, declaration.fileUri); |
| } |
| }); |
| } else if (declaration is SourceTypeAliasBuilder) { |
| Typedef typedef = declaration.build(this); |
| if (!declaration.isPatch && !declaration.isDuplicate) { |
| library.addTypedef(typedef); |
| } |
| } else if (declaration is EnumBuilder) { |
| Class cls = declaration.build(this, coreLibrary); |
| if (!declaration.isPatch) { |
| cls.name += findDuplicateSuffix(declaration); |
| library.addClass(cls); |
| } |
| } else if (declaration is PrefixBuilder) { |
| // Ignored. Kernel doesn't represent prefixes. |
| return; |
| } else if (declaration is BuiltinTypeDeclarationBuilder) { |
| // Nothing needed. |
| return; |
| } else { |
| unhandled("${declaration.runtimeType}", "buildBuilder", |
| declaration.charOffset, declaration.fileUri); |
| return; |
| } |
| } |
| |
| void addNativeDependency(String nativeImportPath) { |
| MemberBuilder constructor = loader.getNativeAnnotation(); |
| Arguments arguments = |
| new Arguments(<Expression>[new StringLiteral(nativeImportPath)]); |
| Expression annotation; |
| if (constructor.isConstructor) { |
| annotation = new ConstructorInvocation(constructor.member, arguments) |
| ..isConst = true; |
| } else { |
| annotation = new StaticInvocation(constructor.member, arguments) |
| ..isConst = true; |
| } |
| library.addAnnotation(annotation); |
| } |
| |
| void addDependencies(Library library, Set<SourceLibraryBuilder> seen) { |
| if (!seen.add(this)) { |
| return; |
| } |
| |
| // Merge import and export lists to have the dependencies in source order. |
| // This is required for the DietListener to correctly match up metadata. |
| int importIndex = 0; |
| int exportIndex = 0; |
| while (importIndex < imports.length || exportIndex < exports.length) { |
| if (exportIndex >= exports.length || |
| (importIndex < imports.length && |
| imports[importIndex].charOffset < |
| exports[exportIndex].charOffset)) { |
| // Add import |
| Import import = imports[importIndex++]; |
| |
| // Rather than add a LibraryDependency, we attach an annotation. |
| if (import.nativeImportPath != null) { |
| addNativeDependency(import.nativeImportPath); |
| continue; |
| } |
| |
| if (import.deferred && import.prefixBuilder?.dependency != null) { |
| library.addDependency(import.prefixBuilder.dependency); |
| } else { |
| library.addDependency(new LibraryDependency.import( |
| import.imported.library, |
| name: import.prefix, |
| combinators: toKernelCombinators(import.combinators)) |
| ..fileOffset = import.charOffset); |
| } |
| } else { |
| // Add export |
| Export export = exports[exportIndex++]; |
| library.addDependency(new LibraryDependency.export( |
| export.exported.library, |
| combinators: toKernelCombinators(export.combinators)) |
| ..fileOffset = export.charOffset); |
| } |
| } |
| |
| for (SourceLibraryBuilder part in parts) { |
| part.addDependencies(library, seen); |
| } |
| } |
| |
| @override |
| Builder computeAmbiguousDeclaration( |
| String name, Builder declaration, Builder other, int charOffset, |
| {bool isExport: false, bool isImport: false}) { |
| // TODO(ahe): Can I move this to Scope or Prefix? |
| if (declaration == other) return declaration; |
| if (declaration is InvalidTypeDeclarationBuilder) return declaration; |
| if (other is InvalidTypeDeclarationBuilder) return other; |
| if (declaration is AccessErrorBuilder) { |
| AccessErrorBuilder error = declaration; |
| declaration = error.builder; |
| } |
| if (other is AccessErrorBuilder) { |
| AccessErrorBuilder error = other; |
| other = error.builder; |
| } |
| bool isLocal = false; |
| bool isLoadLibrary = false; |
| Builder preferred; |
| Uri uri; |
| Uri otherUri; |
| Uri preferredUri; |
| Uri hiddenUri; |
| if (scope.lookupLocalMember(name, setter: false) == declaration) { |
| isLocal = true; |
| preferred = declaration; |
| hiddenUri = computeLibraryUri(other); |
| } else { |
| uri = computeLibraryUri(declaration); |
| otherUri = computeLibraryUri(other); |
| if (declaration is LoadLibraryBuilder) { |
| isLoadLibrary = true; |
| preferred = declaration; |
| preferredUri = otherUri; |
| } else if (other is LoadLibraryBuilder) { |
| isLoadLibrary = true; |
| preferred = other; |
| preferredUri = uri; |
| } else if (otherUri?.scheme == "dart" && uri?.scheme != "dart") { |
| preferred = declaration; |
| preferredUri = uri; |
| hiddenUri = otherUri; |
| } else if (uri?.scheme == "dart" && otherUri?.scheme != "dart") { |
| preferred = other; |
| preferredUri = otherUri; |
| hiddenUri = uri; |
| } |
| } |
| if (preferred != null) { |
| if (isLocal) { |
| Template<Message Function(String name, Uri uri)> template = isExport |
| ? templateLocalDefinitionHidesExport |
| : templateLocalDefinitionHidesImport; |
| addProblem(template.withArguments(name, hiddenUri), charOffset, |
| noLength, fileUri); |
| } else if (isLoadLibrary) { |
| addProblem(templateLoadLibraryHidesMember.withArguments(preferredUri), |
| charOffset, noLength, fileUri); |
| } else { |
| Template<Message Function(String name, Uri uri, Uri uri2)> template = |
| isExport ? templateExportHidesExport : templateImportHidesImport; |
| addProblem(template.withArguments(name, preferredUri, hiddenUri), |
| charOffset, noLength, fileUri); |
| } |
| return preferred; |
| } |
| if (declaration.next == null && other.next == null) { |
| if (isImport && declaration is PrefixBuilder && other is PrefixBuilder) { |
| // Handles the case where the same prefix is used for different |
| // imports. |
| return declaration |
| ..exportScope.merge(other.exportScope, |
| (String name, Builder existing, Builder member) { |
| return computeAmbiguousDeclaration( |
| name, existing, member, charOffset, |
| isExport: isExport, isImport: isImport); |
| }); |
| } |
| } |
| Template<Message Function(String name, Uri uri, Uri uri2)> template = |
| isExport ? templateDuplicatedExport : templateDuplicatedImport; |
| Message message = template.withArguments(name, uri, otherUri); |
| addProblem(message, charOffset, noLength, fileUri); |
| Template<Message Function(String name, Uri uri, Uri uri2)> builderTemplate = |
| isExport |
| ? templateDuplicatedExportInType |
| : templateDuplicatedImportInType; |
| message = builderTemplate.withArguments( |
| name, |
| // TODO(ahe): We should probably use a context object here |
| // instead of including URIs in this message. |
| uri, |
| otherUri); |
| // We report the error lazily (setting suppressMessage to false) because the |
| // spec 18.1 states that 'It is not an error if N is introduced by two or |
| // more imports but never referred to.' |
| return new InvalidTypeDeclarationBuilder( |
| name, message.withLocation(fileUri, charOffset, name.length), |
| suppressMessage: false); |
| } |
| |
| int finishDeferredLoadTearoffs() { |
| int total = 0; |
| for (Import import in imports) { |
| if (import.deferred) { |
| Procedure tearoff = import.prefixBuilder.loadLibraryBuilder.tearoff; |
| if (tearoff != null) library.addProcedure(tearoff); |
| total++; |
| } |
| } |
| return total; |
| } |
| |
| int finishForwarders() { |
| int count = 0; |
| CloneVisitorNotMembers cloner = new CloneVisitorNotMembers(); |
| for (int i = 0; i < forwardersOrigins.length; i += 2) { |
| Procedure forwarder = forwardersOrigins[i]; |
| Procedure origin = forwardersOrigins[i + 1]; |
| |
| int positionalCount = origin.function.positionalParameters.length; |
| if (forwarder.function.positionalParameters.length != positionalCount) { |
| return unexpected( |
| "$positionalCount", |
| "${forwarder.function.positionalParameters.length}", |
| origin.fileOffset, |
| origin.fileUri); |
| } |
| for (int j = 0; j < positionalCount; ++j) { |
| VariableDeclaration forwarderParameter = |
| forwarder.function.positionalParameters[j]; |
| VariableDeclaration originParameter = |
| origin.function.positionalParameters[j]; |
| if (originParameter.initializer != null) { |
| forwarderParameter.initializer = |
| cloner.clone(originParameter.initializer); |
| forwarderParameter.initializer.parent = forwarderParameter; |
| } |
| } |
| |
| Map<String, VariableDeclaration> originNamedMap = |
| <String, VariableDeclaration>{}; |
| for (VariableDeclaration originNamed in origin.function.namedParameters) { |
| originNamedMap[originNamed.name] = originNamed; |
| } |
| for (VariableDeclaration forwarderNamed |
| in forwarder.function.namedParameters) { |
| VariableDeclaration originNamed = originNamedMap[forwarderNamed.name]; |
| if (originNamed == null) { |
| return unhandled( |
| "null", forwarder.name.text, origin.fileOffset, origin.fileUri); |
| } |
| if (originNamed.initializer == null) continue; |
| forwarderNamed.initializer = cloner.clone(originNamed.initializer); |
| forwarderNamed.initializer.parent = forwarderNamed; |
| } |
| |
| ++count; |
| } |
| forwardersOrigins.clear(); |
| return count; |
| } |
| |
| void addNativeMethod(FunctionBuilder method) { |
| nativeMethods.add(method); |
| } |
| |
| int finishNativeMethods() { |
| for (FunctionBuilder method in nativeMethods) { |
| method.becomeNative(loader); |
| } |
| return nativeMethods.length; |
| } |
| |
| /// Creates a copy of [original] into the scope of [declaration]. |
| /// |
| /// This is used for adding copies of class type parameters to factory |
| /// methods and unnamed mixin applications, and for adding copies of |
| /// extension type parameters to extension instance methods. |
| /// |
| /// If [synthesizeTypeParameterNames] is `true` the names of the |
| /// [TypeParameter] are prefix with '#' to indicate that their synthesized. |
| List<TypeVariableBuilder> copyTypeVariables( |
| List<TypeVariableBuilder> original, TypeParameterScopeBuilder declaration, |
| {bool isExtensionTypeParameter: false}) { |
| List<TypeBuilder> newTypes = <TypeBuilder>[]; |
| List<TypeVariableBuilder> copy = <TypeVariableBuilder>[]; |
| for (TypeVariableBuilder variable in original) { |
| TypeVariableBuilder newVariable = new TypeVariableBuilder( |
| variable.name, this, variable.charOffset, |
| bound: variable.bound?.clone(newTypes), |
| isExtensionTypeParameter: isExtensionTypeParameter, |
| variableVariance: |
| variable.parameter.isLegacyCovariant ? null : variable.variance); |
| copy.add(newVariable); |
| boundlessTypeVariables.add(newVariable); |
| } |
| for (TypeBuilder newType in newTypes) { |
| declaration.addType(new UnresolvedType(newType, -1, null)); |
| } |
| return copy; |
| } |
| |
| int finishTypeVariables(ClassBuilder object, TypeBuilder dynamicType) { |
| int count = boundlessTypeVariables.length; |
| for (TypeVariableBuilder builder in boundlessTypeVariables) { |
| builder.finish(this, object, dynamicType); |
| } |
| boundlessTypeVariables.clear(); |
| |
| TypeVariableBuilder.finishNullabilities(this, pendingNullabilities); |
| pendingNullabilities.clear(); |
| |
| return count; |
| } |
| |
| int computeVariances() { |
| int count = 0; |
| for (Builder declaration in libraryDeclaration.members.values) { |
| if (declaration is TypeAliasBuilder && |
| declaration.typeVariablesCount > 0) { |
| for (TypeVariableBuilder typeParameter in declaration.typeVariables) { |
| typeParameter.variance = computeTypeVariableBuilderVariance( |
| typeParameter, declaration.type, this); |
| ++count; |
| } |
| } |
| } |
| return count; |
| } |
| |
| int computeDefaultTypes(TypeBuilder dynamicType, TypeBuilder nullType, |
| TypeBuilder bottomType, ClassBuilder objectClass) { |
| int count = 0; |
| |
| int computeDefaultTypesForVariables(List<TypeVariableBuilder> variables, |
| {bool inErrorRecovery}) { |
| if (variables == null) return 0; |
| |
| bool haveErroneousBounds = false; |
| if (!inErrorRecovery) { |
| for (int i = 0; i < variables.length; ++i) { |
| TypeVariableBuilder variable = variables[i]; |
| List<TypeBuilder> genericFunctionTypes = <TypeBuilder>[]; |
| findGenericFunctionTypes(variable.bound, |
| result: genericFunctionTypes); |
| if (genericFunctionTypes.length > 0) { |
| haveErroneousBounds = true; |
| addProblem(messageGenericFunctionTypeInBound, variable.charOffset, |
| variable.name.length, variable.fileUri); |
| } |
| } |
| |
| if (!haveErroneousBounds) { |
| List<TypeBuilder> calculatedBounds = calculateBounds( |
| variables, |
| dynamicType, |
| isNonNullableByDefault ? bottomType : nullType, |
| objectClass); |
| for (int i = 0; i < variables.length; ++i) { |
| variables[i].defaultType = calculatedBounds[i]; |
| } |
| } |
| } |
| |
| if (inErrorRecovery || haveErroneousBounds) { |
| // Use dynamic in case of errors. |
| for (int i = 0; i < variables.length; ++i) { |
| variables[i].defaultType = dynamicType; |
| } |
| } |
| |
| return variables.length; |
| } |
| |
| void reportIssues(List<Object> issues) { |
| for (int i = 0; i < issues.length; i += 3) { |
| TypeDeclarationBuilder declaration = issues[i]; |
| Message message = issues[i + 1]; |
| List<LocatedMessage> context = issues[i + 2]; |
| |
| addProblem(message, declaration.charOffset, declaration.name.length, |
| declaration.fileUri, |
| context: context); |
| } |
| } |
| |
| for (Builder declaration in libraryDeclaration.members.values) { |
| if (declaration is ClassBuilder) { |
| { |
| List<Object> issues = getNonSimplicityIssuesForDeclaration( |
| declaration, |
| performErrorRecovery: true); |
| reportIssues(issues); |
| count += computeDefaultTypesForVariables(declaration.typeVariables, |
| inErrorRecovery: issues.isNotEmpty); |
| |
| declaration.constructors.forEach((String name, Builder member) { |
| if (member is ProcedureBuilder) { |
| assert(member.isFactory, |
| "Unexpected constructor member (${member.runtimeType})."); |
| count += computeDefaultTypesForVariables(member.typeVariables, |
| // Type variables are inherited from the class so if the class |
| // has issues, so does the factory constructors. |
| inErrorRecovery: issues.isNotEmpty); |
| } else { |
| assert(member is ConstructorBuilder, |
| "Unexpected constructor member (${member.runtimeType})."); |
| } |
| }); |
| } |
| declaration.forEach((String name, Builder member) { |
| if (member is ProcedureBuilder) { |
| List<Object> issues = |
| getNonSimplicityIssuesForTypeVariables(member.typeVariables); |
| reportIssues(issues); |
| count += computeDefaultTypesForVariables(member.typeVariables, |
| inErrorRecovery: issues.isNotEmpty); |
| } else { |
| assert(member is FieldBuilder, |
| "Unexpected class member $member (${member.runtimeType})."); |
| } |
| }); |
| } else if (declaration is TypeAliasBuilder) { |
| List<Object> issues = getNonSimplicityIssuesForDeclaration(declaration, |
| performErrorRecovery: true); |
| reportIssues(issues); |
| count += computeDefaultTypesForVariables(declaration.typeVariables, |
| inErrorRecovery: issues.isNotEmpty); |
| } else if (declaration is FunctionBuilder) { |
| List<Object> issues = |
| getNonSimplicityIssuesForTypeVariables(declaration.typeVariables); |
| reportIssues(issues); |
| count += computeDefaultTypesForVariables(declaration.typeVariables, |
| inErrorRecovery: issues.isNotEmpty); |
| } else if (declaration is ExtensionBuilder) { |
| { |
| List<Object> issues = getNonSimplicityIssuesForDeclaration( |
| declaration, |
| performErrorRecovery: true); |
| reportIssues(issues); |
| count += computeDefaultTypesForVariables(declaration.typeParameters, |
| inErrorRecovery: issues.isNotEmpty); |
| } |
| declaration.forEach((String name, Builder member) { |
| if (member is ProcedureBuilder) { |
| List<Object> issues = |
| getNonSimplicityIssuesForTypeVariables(member.typeVariables); |
| reportIssues(issues); |
| count += computeDefaultTypesForVariables(member.typeVariables, |
| inErrorRecovery: issues.isNotEmpty); |
| } else { |
| assert(member is FieldBuilder, |
| "Unexpected extension member $member (${member.runtimeType})."); |
| } |
| }); |
| } else { |
| assert( |
| declaration is FieldBuilder || |
| declaration is PrefixBuilder || |
| declaration is DynamicTypeDeclarationBuilder || |
| declaration is NeverTypeDeclarationBuilder, |
| "Unexpected top level member $declaration " |
| "(${declaration.runtimeType})."); |
| } |
| } |
| |
| return count; |
| } |
| |
| @override |
| void applyPatches() { |
| if (!isPatch) return; |
| |
| if (languageVersion != origin.languageVersion) { |
| List<LocatedMessage> context = <LocatedMessage>[]; |
| if (origin.languageVersion.isExplicit) { |
| context.add(messageLanguageVersionLibraryContext.withLocation( |
| origin.languageVersion.fileUri, |
| origin.languageVersion.charOffset, |
| origin.languageVersion.charCount)); |
| } |
| |
| if (languageVersion.isExplicit) { |
| addProblem( |
| messageLanguageVersionMismatchInPatch, |
| languageVersion.charOffset, |
| languageVersion.charCount, |
| languageVersion.fileUri, |
| context: context); |
| } else { |
| addProblem(messageLanguageVersionMismatchInPatch, -1, noLength, fileUri, |
| context: context); |
| } |
| } |
| |
| NameIterator originDeclarations = origin.nameIterator; |
| while (originDeclarations.moveNext()) { |
| String name = originDeclarations.name; |
| Builder member = originDeclarations.current; |
| bool isSetter = member.isSetter; |
| Builder patch = scope.lookupLocalMember(name, setter: isSetter); |
| if (patch != null) { |
| // [patch] has the same name as a [member] in [origin] library, so it |
| // must be a patch to [member]. |
| member.applyPatch(patch); |
| // TODO(ahe): Verify that patch has the @patch annotation. |
| } else { |
| // No member with [name] exists in this library already. So we need to |
| // import it into the patch library. This ensures that the origin |
| // library is in scope of the patch library. |
| if (isSetter) { |
| scopeBuilder.addSetter(name, member); |
| } else { |
| scopeBuilder.addMember(name, member); |
| } |
| } |
| } |
| NameIterator patchDeclarations = nameIterator; |
| while (patchDeclarations.moveNext()) { |
| String name = patchDeclarations.name; |
| Builder member = patchDeclarations.current; |
| // We need to inject all non-patch members into the origin library. This |
| // should only apply to private members. |
| if (member.isPatch) { |
| // Ignore patches. |
| } else if (name.startsWith("_")) { |
| origin.injectMemberFromPatch(name, member); |
| } else { |
| origin.exportMemberFromPatch(name, member); |
| } |
| } |
| } |
| |
| int finishPatchMethods() { |
| if (!isPatch) return 0; |
| int count = 0; |
| Iterator<Builder> iterator = this.iterator; |
| while (iterator.moveNext()) { |
| count += iterator.current.finishPatch(); |
| } |
| return count; |
| } |
| |
| void injectMemberFromPatch(String name, Builder member) { |
| if (member.isSetter) { |
| assert(scope.lookupLocalMember(name, setter: true) == null); |
| scopeBuilder.addSetter(name, member); |
| } else { |
| assert(scope.lookupLocalMember(name, setter: false) == null); |
| scopeBuilder.addMember(name, member); |
| } |
| } |
| |
| void exportMemberFromPatch(String name, Builder member) { |
| if (importUri.scheme != "dart" || !importUri.path.startsWith("_")) { |
| addProblem(templatePatchInjectionFailed.withArguments(name, importUri), |
| member.charOffset, noLength, member.fileUri); |
| } |
| // Platform-private libraries, such as "dart:_internal" have special |
| // semantics: public members are injected into the origin library. |
| // TODO(ahe): See if we can remove this special case. |
| |
| // If this member already exist in the origin library scope, it should |
| // have been marked as patch. |
| assert((member.isSetter && |
| scope.lookupLocalMember(name, setter: true) == null) || |
| (!member.isSetter && |
| scope.lookupLocalMember(name, setter: false) == null)); |
| addToExportScope(name, member); |
| } |
| |
| void reportTypeArgumentIssues( |
| Iterable<TypeArgumentIssue> issues, Uri fileUri, int offset, |
| {bool inferred, |
| TypeArgumentsInfo typeArgumentsInfo, |
| DartType targetReceiver, |
| String targetName}) { |
| for (TypeArgumentIssue issue in issues) { |
| DartType argument = issue.argument; |
| TypeParameter typeParameter = issue.typeParameter; |
| |
| Message message; |
| bool issueInferred = inferred ?? |
| typeArgumentsInfo?.isInferred(issue.index) ?? |
| inferredTypes.contains(argument); |
| offset = |
| typeArgumentsInfo?.getOffsetForIndex(issue.index, offset) ?? offset; |
| if (argument is FunctionType && argument.typeParameters.length > 0) { |
| if (issueInferred) { |
| message = templateGenericFunctionTypeInferredAsActualTypeArgument |
| .withArguments(argument, isNonNullableByDefault); |
| } else { |
| message = messageGenericFunctionTypeUsedAsActualTypeArgument; |
| } |
| typeParameter = null; |
| } else { |
| if (issue.enclosingType == null && targetReceiver != null) { |
| if (issueInferred) { |
| message = |
| templateIncorrectTypeArgumentQualifiedInferred.withArguments( |
| argument, |
| typeParameter.bound, |
| typeParameter.name, |
| targetReceiver, |
| targetName, |
| isNonNullableByDefault); |
| } else { |
| message = templateIncorrectTypeArgumentQualified.withArguments( |
| argument, |
| typeParameter.bound, |
| typeParameter.name, |
| targetReceiver, |
| targetName, |
| isNonNullableByDefault); |
| } |
| } else { |
| String enclosingName = issue.enclosingType == null |
| ? targetName |
| : getGenericTypeName(issue.enclosingType); |
| assert(enclosingName != null); |
| if (issueInferred) { |
| message = templateIncorrectTypeArgumentInferred.withArguments( |
| argument, |
| typeParameter.bound, |
| typeParameter.name, |
| enclosingName, |
| isNonNullableByDefault); |
| } else { |
| message = templateIncorrectTypeArgument.withArguments( |
| argument, |
| typeParameter.bound, |
| typeParameter.name, |
| enclosingName, |
| isNonNullableByDefault); |
| } |
| } |
| } |
| |
| reportTypeArgumentIssue(message, fileUri, offset, typeParameter); |
| } |
| } |
| |
| void reportTypeArgumentIssue(Message message, Uri fileUri, int fileOffset, |
| TypeParameter typeParameter) { |
| List<LocatedMessage> context; |
| if (typeParameter != null && typeParameter.fileOffset != -1) { |
| // It looks like when parameters come from patch files, they don't |
| // have a reportable location. |
| context = <LocatedMessage>[ |
| messageIncorrectTypeArgumentVariable.withLocation( |
| typeParameter.location.file, typeParameter.fileOffset, noLength) |
| ]; |
| } |
| addProblem(message, fileOffset, noLength, fileUri, context: context); |
| } |
| |
| void checkTypesInField( |
| FieldBuilder fieldBuilder, TypeEnvironment typeEnvironment) { |
| // Check the bounds in the field's type. |
| checkBoundsInType(fieldBuilder.fieldType, typeEnvironment, |
| fieldBuilder.fileUri, fieldBuilder.charOffset, |
| allowSuperBounded: true); |
| |
| // Check that the field has an initializer if its type is potentially |
| // non-nullable. |
| if (isNonNullableByDefault) { |
| // Only static and top-level fields are checked here. Instance fields are |
| // checked elsewhere. |
| DartType fieldType = fieldBuilder.fieldType; |
| if (!fieldBuilder.isDeclarationInstanceMember && |
| !fieldBuilder.isLate && |
| !fieldBuilder.isExternal && |
| fieldType is! InvalidType && |
| fieldType.isPotentiallyNonNullable && |
| !fieldBuilder.hasInitializer) { |
| addProblem( |
| templateFieldNonNullableWithoutInitializerError.withArguments( |
| fieldBuilder.name, |
| fieldBuilder.fieldType, |
| isNonNullableByDefault), |
| fieldBuilder.charOffset, |
| fieldBuilder.name.length, |
| fieldBuilder.fileUri); |
| } |
| } |
| } |
| |
| void checkInitializersInFormals( |
| List<FormalParameterBuilder> formals, TypeEnvironment typeEnvironment) { |
| if (!isNonNullableByDefault) return; |
| |
| for (FormalParameterBuilder formal in formals) { |
| bool isOptionalPositional = formal.isOptional && formal.isPositional; |
| bool isOptionalNamed = !formal.isNamedRequired && formal.isNamed; |
| bool isOptional = isOptionalPositional || isOptionalNamed; |
| if (isOptional && |
| formal.variable.type.isPotentiallyNonNullable && |
| !formal.hasDeclaredInitializer) { |
| addProblem( |
| templateOptionalNonNullableWithoutInitializerError.withArguments( |
| formal.name, formal.variable.type, isNonNullableByDefault), |
| formal.charOffset, |
| formal.name.length, |
| formal.fileUri); |
| } |
| } |
| } |
| |
| void checkBoundsInTypeParameters(TypeEnvironment typeEnvironment, |
| List<TypeParameter> typeParameters, Uri fileUri) { |
| final DartType bottomType = library.isNonNullableByDefault |
| ? const NeverType(Nullability.nonNullable) |
| : const NullType(); |
| |
| // Check in bounds of own type variables. |
| for (TypeParameter parameter in typeParameters) { |
| Set<TypeArgumentIssue> issues = {}; |
| issues.addAll(findTypeArgumentIssues( |
| library, |
| parameter.bound, |
| typeEnvironment, |
| SubtypeCheckMode.ignoringNullabilities, |
| bottomType, |
| allowSuperBounded: true) ?? |
| const []); |
| if (library.isNonNullableByDefault) { |
| issues.addAll(findTypeArgumentIssues(library, parameter.bound, |
| typeEnvironment, SubtypeCheckMode.withNullabilities, bottomType, |
| allowSuperBounded: true) ?? |
| const []); |
| } |
| for (TypeArgumentIssue issue in issues) { |
| DartType argument = issue.argument; |
| TypeParameter typeParameter = issue.typeParameter; |
| if (inferredTypes.contains(argument)) { |
| // Inference in type expressions in the supertypes boils down to |
| // instantiate-to-bound which shouldn't produce anything that breaks |
| // the bounds after the non-simplicity checks are done. So, any |
| // violation here is the result of non-simple bounds, and the error |
| // is reported elsewhere. |
| continue; |
| } |
| |
| if (argument is FunctionType && argument.typeParameters.length > 0) { |
| reportTypeArgumentIssue( |
| messageGenericFunctionTypeUsedAsActualTypeArgument, |
| fileUri, |
| parameter.fileOffset, |
| null); |
| } else { |
| reportTypeArgumentIssue( |
| templateIncorrectTypeArgument.withArguments( |
| argument, |
| typeParameter.bound, |
| typeParameter.name, |
| getGenericTypeName(issue.enclosingType), |
| library.isNonNullableByDefault), |
| fileUri, |
| parameter.fileOffset, |
| typeParameter); |
| } |
| } |
| } |
| } |
| |
| void checkBoundsInFunctionNodeParts( |
| TypeEnvironment typeEnvironment, Uri fileUri, int fileOffset, |
| {List<TypeParameter> typeParameters, |
| List<VariableDeclaration> positionalParameters, |
| List<VariableDeclaration> namedParameters, |
| DartType returnType, |
| int requiredParameterCount}) { |
| if (typeParameters != null) { |
| for (TypeParameter parameter in typeParameters) { |
| checkBoundsInType( |
| parameter.bound, typeEnvironment, fileUri, parameter.fileOffset, |
| allowSuperBounded: true); |
| } |
| } |
| if (positionalParameters != null) { |
| for (int i = 0; i < positionalParameters.length; ++i) { |
| VariableDeclaration parameter = positionalParameters[i]; |
| checkBoundsInType( |
| parameter.type, typeEnvironment, fileUri, parameter.fileOffset, |
| allowSuperBounded: true); |
| } |
| } |
| if (namedParameters != null) { |
| for (int i = 0; i < namedParameters.length; ++i) { |
| VariableDeclaration named = namedParameters[i]; |
| checkBoundsInType( |
| named.type, typeEnvironment, fileUri, named.fileOffset, |
| allowSuperBounded: true); |
| } |
| } |
| if (returnType != null) { |
| final DartType bottomType = isNonNullableByDefault |
| ? const NeverType(Nullability.nonNullable) |
| : const NullType(); |
| Set<TypeArgumentIssue> issues = {}; |
| issues.addAll(findTypeArgumentIssues(library, returnType, typeEnvironment, |
| SubtypeCheckMode.ignoringNullabilities, bottomType, |
| allowSuperBounded: true) ?? |
| const []); |
| if (isNonNullableByDefault) { |
| issues.addAll(findTypeArgumentIssues(library, returnType, |
| typeEnvironment, SubtypeCheckMode.withNullabilities, bottomType, |
| allowSuperBounded: true) ?? |
| const []); |
| } |
| for (TypeArgumentIssue issue in issues) { |
| DartType argument = issue.argument; |
| TypeParameter typeParameter = issue.typeParameter; |
| |
| // We don't need to check if [argument] was inferred or specified |
| // here, because inference in return types boils down to instantiate- |
| // -to-bound, and it can't provide a type that violates the bound. |
| if (argument is FunctionType && argument.typeParameters.length > 0) { |
| reportTypeArgumentIssue( |
| messageGenericFunctionTypeUsedAsActualTypeArgument, |
| fileUri, |
| fileOffset, |
| null); |
| } else { |
| reportTypeArgumentIssue( |
| templateIncorrectTypeArgumentInReturnType.withArguments( |
| argument, |
| typeParameter.bound, |
| typeParameter.name, |
| getGenericTypeName(issue.enclosingType), |
| isNonNullableByDefault), |
| fileUri, |
| fileOffset, |
| typeParameter); |
| } |
| } |
| } |
| } |
| |
| void checkTypesInProcedureBuilder( |
| ProcedureBuilder procedureBuilder, TypeEnvironment typeEnvironment) { |
| checkBoundsInFunctionNode(procedureBuilder.procedure.function, |
| typeEnvironment, procedureBuilder.fileUri); |
| if (procedureBuilder.formals != null && |
| !(procedureBuilder.isAbstract || procedureBuilder.isExternal)) { |
| checkInitializersInFormals(procedureBuilder.formals, typeEnvironment); |
| } |
| } |
| |
| void checkTypesInConstructorBuilder( |
| ConstructorBuilder constructorBuilder, TypeEnvironment typeEnvironment) { |
| checkBoundsInFunctionNode( |
| constructorBuilder.constructor.function, typeEnvironment, fileUri); |
| if (!constructorBuilder.isExternal && constructorBuilder.formals != null) { |
| checkInitializersInFormals(constructorBuilder.formals, typeEnvironment); |
| } |
| } |
| |
| void checkTypesInRedirectingFactoryBuilder( |
| RedirectingFactoryBuilder redirectingFactoryBuilder, |
| TypeEnvironment typeEnvironment) { |
| checkBoundsInFunctionNode(redirectingFactoryBuilder.procedure.function, |
| typeEnvironment, redirectingFactoryBuilder.fileUri); |
| // Default values are not required on redirecting factory constructors so |
| // we don't call [checkInitializersInFormals]. |
| } |
| |
| void checkBoundsInFunctionNode( |
| FunctionNode function, TypeEnvironment typeEnvironment, Uri fileUri) { |
| checkBoundsInFunctionNodeParts( |
| typeEnvironment, fileUri, function.fileOffset, |
| typeParameters: function.typeParameters, |
| positionalParameters: function.positionalParameters, |
| namedParameters: function.namedParameters, |
| returnType: function.returnType, |
| requiredParameterCount: function.requiredParameterCount); |
| } |
| |
| void checkBoundsInListLiteral( |
| ListLiteral node, TypeEnvironment typeEnvironment, Uri fileUri, |
| {bool inferred = false}) { |
| checkBoundsInType( |
| node.typeArgument, typeEnvironment, fileUri, node.fileOffset, |
| inferred: inferred, allowSuperBounded: true); |
| } |
| |
| void checkBoundsInSetLiteral( |
| SetLiteral node, TypeEnvironment typeEnvironment, Uri fileUri, |
| {bool inferred = false}) { |
| checkBoundsInType( |
| node.typeArgument, typeEnvironment, fileUri, node.fileOffset, |
| inferred: inferred, allowSuperBounded: true); |
| } |
| |
| void checkBoundsInMapLiteral( |
| MapLiteral node, TypeEnvironment typeEnvironment, Uri fileUri, |
| {bool inferred = false}) { |
| checkBoundsInType(node.keyType, typeEnvironment, fileUri, node.fileOffset, |
| inferred: inferred, allowSuperBounded: true); |
| checkBoundsInType(node.valueType, typeEnvironment, fileUri, node.fileOffset, |
| inferred: inferred, allowSuperBounded: true); |
| } |
| |
| void checkBoundsInType( |
| DartType type, TypeEnvironment typeEnvironment, Uri fileUri, int offset, |
| {bool inferred, bool allowSuperBounded = true}) { |
| final DartType bottomType = isNonNullableByDefault |
| ? const NeverType(Nullability.nonNullable) |
| : const NullType(); |
| Set<TypeArgumentIssue> issues = {}; |
| issues.addAll(findTypeArgumentIssues(library, type, typeEnvironment, |
| SubtypeCheckMode.ignoringNullabilities, bottomType, |
| allowSuperBounded: allowSuperBounded) ?? |
| const []); |
| if (isNonNullableByDefault) { |
| issues.addAll(findTypeArgumentIssues(library, type, typeEnvironment, |
| SubtypeCheckMode.withNullabilities, bottomType, |
| allowSuperBounded: allowSuperBounded) ?? |
| const []); |
| } |
| reportTypeArgumentIssues(issues, fileUri, offset, inferred: inferred); |
| } |
| |
| void checkBoundsInVariableDeclaration( |
| VariableDeclaration node, TypeEnvironment typeEnvironment, Uri fileUri, |
| {bool inferred = false}) { |
| if (node.type == null) return; |
| checkBoundsInType(node.type, typeEnvironment, fileUri, node.fileOffset, |
| inferred: inferred, allowSuperBounded: true); |
| } |
| |
| void checkBoundsInConstructorInvocation( |
| ConstructorInvocation node, TypeEnvironment typeEnvironment, Uri fileUri, |
| {bool inferred = false}) { |
| if (node.arguments.types.isEmpty) return; |
| Constructor constructor = node.target; |
| Class klass = constructor.enclosingClass; |
| DartType constructedType = new InterfaceType( |
| klass, klass.enclosingLibrary.nonNullable, node.arguments.types); |
| checkBoundsInType( |
| constructedType, typeEnvironment, fileUri, node.fileOffset, |
| inferred: inferred, allowSuperBounded: false); |
| } |
| |
| void checkBoundsInFactoryInvocation( |
| StaticInvocation node, TypeEnvironment typeEnvironment, Uri fileUri, |
| {bool inferred = false}) { |
| if (node.arguments.types.isEmpty) return; |
| Procedure factory = node.target; |
| assert(factory.isFactory); |
| Class klass = factory.enclosingClass; |
| DartType constructedType = new InterfaceType( |
| klass, klass.enclosingLibrary.nonNullable, node.arguments.types); |
| checkBoundsInType( |
| constructedType, typeEnvironment, fileUri, node.fileOffset, |
| inferred: inferred, allowSuperBounded: false); |
| } |
| |
| void checkBoundsInStaticInvocation( |
| StaticInvocation node, |
| TypeEnvironment typeEnvironment, |
| Uri fileUri, |
| TypeArgumentsInfo typeArgumentsInfo) { |
| // TODO(johnniwinther): Handle partially inferred type arguments in |
| // extension method calls. Currently all are considered inferred in the |
| // error messages. |
| if (node.arguments.types.isEmpty) return; |
| Class klass = node.target.enclosingClass; |
| List<TypeParameter> parameters = node.target.function.typeParameters; |
| List<DartType> arguments = node.arguments.types; |
| // The following error is to be reported elsewhere. |
| if (parameters.length != arguments.length) return; |
| |
| final DartType bottomType = isNonNullableByDefault |
| ? const NeverType(Nullability.nonNullable) |
| : const NullType(); |
| Set<TypeArgumentIssue> issues = {}; |
| issues.addAll(findTypeArgumentIssuesForInvocation( |
| library, |
| parameters, |
| arguments, |
| typeEnvironment, |
| SubtypeCheckMode.ignoringNullabilities, |
| bottomType) ?? |
| const []); |
| if (isNonNullableByDefault) { |
| issues.addAll(findTypeArgumentIssuesForInvocation( |
| library, |
| parameters, |
| arguments, |
| typeEnvironment, |
| SubtypeCheckMode.withNullabilities, |
| bottomType) ?? |
| const []); |
| } |
| if (issues.isNotEmpty) { |
| DartType targetReceiver; |
| if (klass != null) { |
| targetReceiver = |
| new InterfaceType(klass, klass.enclosingLibrary.nonNullable); |
| } |
| String targetName = node.target.name.text; |
| reportTypeArgumentIssues(issues, fileUri, node.fileOffset, |
| typeArgumentsInfo: typeArgumentsInfo, |
| targetReceiver: targetReceiver, |
| targetName: targetName); |
| } |
| } |
| |
| void checkBoundsInMethodInvocation( |
| DartType receiverType, |
| TypeEnvironment typeEnvironment, |
| ClassHierarchy hierarchy, |
| TypeInferrerImpl typeInferrer, |
| Name name, |
| Member interfaceTarget, |
| Arguments arguments, |
| Uri fileUri, |
| int offset) { |
| if (arguments.types.isEmpty) return; |
| Class klass; |
| List<DartType> receiverTypeArguments; |
| if (receiverType is InterfaceType) { |
| klass = receiverType.classNode; |
| receiverTypeArguments = receiverType.typeArguments; |
| } else { |
| return; |
| } |
| // TODO(dmitryas): Find a better way than relying on [interfaceTarget]. |
| Member method = hierarchy.getDispatchTarget(klass, name) ?? interfaceTarget; |
| if (method == null || method is! Procedure) { |
| return; |
| } |
| if (klass != method.enclosingClass) { |
| Supertype parent = |
| hierarchy.getClassAsInstanceOf(klass, method.enclosingClass); |
| klass = method.enclosingClass; |
| receiverTypeArguments = parent.typeArguments; |
| } |
| Map<TypeParameter, DartType> substitutionMap = <TypeParameter, DartType>{}; |
| for (int i = 0; i < receiverTypeArguments.length; ++i) { |
| substitutionMap[klass.typeParameters[i]] = receiverTypeArguments[i]; |
| } |
| List<TypeParameter> methodParameters = method.function.typeParameters; |
| // The error is to be reported elsewhere. |
| if (methodParameters.length != arguments.types.length) return; |
| List<TypeParameter> instantiatedMethodParameters = |
| new List<TypeParameter>.filled(methodParameters.length, null); |
| for (int i = 0; i < instantiatedMethodParameters.length; ++i) { |
| instantiatedMethodParameters[i] = |
| new TypeParameter(methodParameters[i].name); |
| substitutionMap[methodParameters[i]] = |
| new TypeParameterType.forAlphaRenaming( |
| methodParameters[i], instantiatedMethodParameters[i]); |
| } |
| for (int i = 0; i < instantiatedMethodParameters.length; ++i) { |
| instantiatedMethodParameters[i].bound = |
| substitute(methodParameters[i].bound, substitutionMap); |
| } |
| |
| final DartType bottomType = isNonNullableByDefault |
| ? const NeverType(Nullability.nonNullable) |
| : const NullType(); |
| Set<TypeArgumentIssue> issues = {}; |
| issues.addAll(findTypeArgumentIssuesForInvocation( |
| library, |
| instantiatedMethodParameters, |
| arguments.types, |
| typeEnvironment, |
| SubtypeCheckMode.ignoringNullabilities, |
| bottomType) ?? |
| const []); |
| if (isNonNullableByDefault) { |
| issues.addAll(findTypeArgumentIssuesForInvocation( |
| library, |
| instantiatedMethodParameters, |
| arguments.types, |
| typeEnvironment, |
| SubtypeCheckMode.withNullabilities, |
| bottomType) ?? |
| const []); |
| } |
| reportTypeArgumentIssues(issues, fileUri, offset, |
| typeArgumentsInfo: getTypeArgumentsInfo(arguments), |
| targetReceiver: receiverType, |
| targetName: name.text); |
| } |
| |
| void checkTypesInOutline(TypeEnvironment typeEnvironment) { |
| Iterator<Builder> iterator = this.iterator; |
| while (iterator.moveNext()) { |
| Builder declaration = iterator.current; |
| if (declaration is FieldBuilder) { |
| checkTypesInField(declaration, typeEnvironment); |
| } else if (declaration is ProcedureBuilder) { |
| checkTypesInProcedureBuilder(declaration, typeEnvironment); |
| if (declaration.isGetter) { |
| Builder setterDeclaration = |
| scope.lookupLocalMember(declaration.name, setter: true); |
| if (setterDeclaration != null) { |
| checkGetterSetterTypes( |
| declaration, setterDeclaration, typeEnvironment); |
| } |
| } |
| } else if (declaration is SourceClassBuilder) { |
| declaration.checkTypesInOutline(typeEnvironment); |
| } else if (declaration is SourceExtensionBuilder) { |
| declaration.checkTypesInOutline(typeEnvironment); |
| } else { |
| //assert(false, "Unexpected declaration ${declaration.runtimeType}"); |
| } |
| } |
| inferredTypes.clear(); |
| } |
| |
| void registerImplicitlyTypedField(FieldBuilder fieldBuilder) { |
| (_implicitlyTypedFields ??= <FieldBuilder>[]).add(fieldBuilder); |
| } |
| |
| @override |
| List<FieldBuilder> takeImplicitlyTypedFields() { |
| List<FieldBuilder> result = _implicitlyTypedFields; |
| _implicitlyTypedFields = null; |
| return result; |
| } |
| |
| void forEachExtensionInScope(void Function(ExtensionBuilder) f) { |
| if (_extensionsInScope == null) { |
| _extensionsInScope = <ExtensionBuilder>{}; |
| scope.forEachExtension(_extensionsInScope.add); |
| if (_prefixBuilders != null) { |
| for (PrefixBuilder prefix in _prefixBuilders) { |
| prefix.exportScope.forEachExtension(_extensionsInScope.add); |
| } |
| } |
| } |
| _extensionsInScope.forEach(f); |
| } |
| |
| void clearExtensionsInScopeCache() { |
| _extensionsInScope = null; |
| } |
| |
| /// Set to some non-null name when entering a class; set to null when leaving |
| /// the class. |
| /// |
| /// Called in OutlineBuilder.beginClassDeclaration, |
| /// OutlineBuilder.endClassDeclaration, |
| /// OutlineBuilder.beginMixinDeclaration, |
| /// OutlineBuilder.endMixinDeclaration. |
| void setCurrentClassName(String name) { |
| if (name == null) { |
| _currentClassReferencesFromIndexed = null; |
| } else if (referencesFrom != null) { |
| _currentClassReferencesFromIndexed = |
| referencesFromIndexed.lookupIndexedClass(name); |
| } |
| } |
| |
| Procedure lookupLibraryReferenceProcedure(String name, bool setter) { |
| if (referencesFrom == null) return null; |
| if (setter) { |
| return referencesFromIndexed.lookupProcedureSetter(name); |
| } else { |
| return referencesFromIndexed.lookupProcedureNotSetter(name); |
| } |
| } |
| } |
| |
| // The kind of type parameter scope built by a [TypeParameterScopeBuilder] |
| // object. |
| enum TypeParameterScopeKind { |
| library, |
| classOrNamedMixinApplication, |
| classDeclaration, |
| mixinDeclaration, |
| unnamedMixinApplication, |
| namedMixinApplication, |
| extensionDeclaration, |
| typedef, |
| staticOrInstanceMethodOrConstructor, |
| topLevelMethod, |
| factoryMethod, |
| functionType, |
| } |
| |
| /// A builder object preparing for building declarations that can introduce type |
| /// parameter and/or members. |
| /// |
| /// Unlike [Scope], this scope is used during construction of builders to |
| /// ensure types and members are added to and resolved in the correct location. |
| class TypeParameterScopeBuilder { |
| TypeParameterScopeKind _kind; |
| |
| final TypeParameterScopeBuilder parent; |
| |
| final Map<String, Builder> members; |
| |
| final Map<String, Builder> constructors; |
| |
| final Map<String, MemberBuilder> setters; |
| |
| final Set<ExtensionBuilder> extensions; |
| |
| final List<UnresolvedType> types = <UnresolvedType>[]; |
| |
| // TODO(johnniwinther): Stop using [_name] for determining the declaration |
| // kind. |
| String _name; |
| |
| /// Offset of name token, updated by the outline builder along |
| /// with the name as the current declaration changes. |
| int _charOffset; |
| |
| List<TypeVariableBuilder> _typeVariables; |
| |
| /// The type of `this` in instance methods declared in extension declarations. |
| /// |
| /// Instance methods declared in extension declarations methods are extended |
| /// with a synthesized parameter of this type. |
| TypeBuilder _extensionThisType; |
| |
| bool declaresConstConstructor = false; |
| |
| TypeParameterScopeBuilder( |
| this._kind, |
| this.members, |
| this.setters, |
| this.constructors, |
| this.extensions, |
| this._name, |
| this._charOffset, |
| this.parent) { |
| assert(_name != null); |
| } |
| |
| TypeParameterScopeBuilder.library() |
| : this( |
| TypeParameterScopeKind.library, |
| <String, Builder>{}, |
| <String, MemberBuilder>{}, |
| null, // No support for constructors in library scopes. |
| <ExtensionBuilder>{}, |
| "<library>", |
| -1, |
| null); |
| |
| TypeParameterScopeBuilder createNested( |
| TypeParameterScopeKind kind, String name, bool hasMembers) { |
| return new TypeParameterScopeBuilder( |
| kind, |
| hasMembers ? <String, MemberBuilder>{} : null, |
| hasMembers ? <String, MemberBuilder>{} : null, |
| hasMembers ? <String, MemberBuilder>{} : null, |
| null, // No support for extensions in nested scopes. |
| name, |
| -1, |
| this); |
| } |
| |
| /// Registers that this builder is preparing for a class declaration with the |
| /// given [name] and [typeVariables] located [charOffset]. |
| void markAsClassDeclaration( |
| String name, int charOffset, List<TypeVariableBuilder> typeVariables) { |
| assert(_kind == TypeParameterScopeKind.classOrNamedMixinApplication, |
| "Unexpected declaration kind: $_kind"); |
| _kind = TypeParameterScopeKind.classDeclaration; |
| _name = name; |
| _charOffset = charOffset; |
| _typeVariables = typeVariables; |
| } |
| |
| /// Registers that this builder is preparing for a named mixin application |
| /// with the given [name] and [typeVariables] located [charOffset]. |
| void markAsNamedMixinApplication( |
| String name, int charOffset, List<TypeVariableBuilder> typeVariables) { |
| assert(_kind == TypeParameterScopeKind.classOrNamedMixinApplication, |
| "Unexpected declaration kind: $_kind"); |
| _kind = TypeParameterScopeKind.namedMixinApplication; |
| _name = name; |
| _charOffset = charOffset; |
| _typeVariables = typeVariables; |
| } |
| |
| /// Registers that this builder is preparing for a mixin declaration with the |
| /// given [name] and [typeVariables] located [charOffset]. |
| void markAsMixinDeclaration( |
| String name, int charOffset, List<TypeVariableBuilder> typeVariables) { |
| // TODO(johnniwinther): Avoid using 'classOrNamedMixinApplication' for mixin |
| // declaration. These are syntactically distinct so we don't need the |
| // transition. |
| assert(_kind == TypeParameterScopeKind.classOrNamedMixinApplication, |
| "Unexpected declaration kind: $_kind"); |
| _kind = TypeParameterScopeKind.mixinDeclaration; |
| _name = name; |
| _charOffset = charOffset; |
| _typeVariables = typeVariables; |
| } |
| |
| /// Registers that this builder is preparing for an extension declaration with |
| /// the given [name] and [typeVariables] located [charOffset]. |
| void markAsExtensionDeclaration( |
| String name, int charOffset, List<TypeVariableBuilder> typeVariables) { |
| assert(_kind == TypeParameterScopeKind.extensionDeclaration, |
| "Unexpected declaration kind: $_kind"); |
| _name = name; |
| _charOffset = charOffset; |
| _typeVariables = typeVariables; |
| } |
| |
| /// Registers the 'extension this type' of the extension declaration prepared |
| /// for by this builder. |
| /// |
| /// See [extensionThisType] for terminology. |
| void registerExtensionThisType(TypeBuilder type) { |
| assert(_kind == TypeParameterScopeKind.extensionDeclaration, |
| "DeclarationBuilder.registerExtensionThisType is not supported $_kind"); |
| assert(_extensionThisType == null, |
| "Extension this type has already been set."); |
| _extensionThisType = type; |
| } |
| |
| /// Returns what kind of declaration this [TypeParameterScopeBuilder] is |
| /// preparing for. |
| /// |
| /// This information is transient for some declarations. In particular |
| /// classes and named mixin applications are initially created with the kind |
| /// [TypeParameterScopeKind.classOrNamedMixinApplication] before a call to |
| /// either [markAsClassDeclaration] or [markAsNamedMixinApplication] sets the |
| /// value to its actual kind. |
| // TODO(johnniwinther): Avoid the transition currently used on mixin |
| // declarations. |
| TypeParameterScopeKind get kind => _kind; |
| |
| String get name => _name; |
| |
| int get charOffset => _charOffset; |
| |
| List<TypeVariableBuilder> get typeVariables => _typeVariables; |
| |
| /// Returns the 'extension this type' of the extension declaration prepared |
| /// for by this builder. |
| /// |
| /// The 'extension this type' is the type mentioned in the on-clause of the |
| /// extension declaration. For instance `B` in this extension declaration: |
| /// |
| /// extension A on B { |
| /// B method() => this; |
| /// } |
| /// |
| /// The 'extension this type' is the type if `this` expression in instance |
| /// methods declared in extension declarations. |
| TypeBuilder get extensionThisType { |
| assert(kind == TypeParameterScopeKind.extensionDeclaration, |
| "DeclarationBuilder.extensionThisType not supported on $kind."); |
| assert(_extensionThisType != null, |
| "DeclarationBuilder.extensionThisType has not been set on $this."); |
| return _extensionThisType; |
| } |
| |
| /// Adds the yet unresolved [type] to this scope builder. |
| /// |
| /// Unresolved type will be resolved through [resolveTypes] when the scope |
| /// is fully built. This allows for resolving self-referencing types, like |
| /// type parameter used in their own bound, for instance `<T extends A<T>>`. |
| void addType(UnresolvedType type) { |
| types.add(type); |
| } |
| |
| /// Resolves type variables in [types] and propagate other types to [parent]. |
| void resolveTypes( |
| List<TypeVariableBuilder> typeVariables, SourceLibraryBuilder library) { |
| Map<String, TypeVariableBuilder> map; |
| if (typeVariables != null) { |
| map = <String, TypeVariableBuilder>{}; |
| for (TypeVariableBuilder builder in typeVariables) { |
| map[builder.name] = builder; |
| } |
| } |
| Scope scope; |
| for (UnresolvedType type in types) { |
| Object nameOrQualified = type.builder.name; |
| String name = nameOrQualified is QualifiedName |
| ? nameOrQualified.qualifier |
| : nameOrQualified; |
| Builder declaration; |
| if (name != null) { |
| if (members != null) { |
| declaration = members[name]; |
| } |
| if (declaration == null && map != null) { |
| declaration = map[name]; |
| } |
| } |
| if (declaration == null) { |
| // Since name didn't resolve in this scope, propagate it to the |
| // parent declaration. |
| parent.addType(type); |
| } else if (nameOrQualified is QualifiedName) { |
| NamedTypeBuilder builder = type.builder; |
| // Attempt to use a member or type variable as a prefix. |
| Message message = templateNotAPrefixInTypeAnnotation.withArguments( |
| flattenName( |
| nameOrQualified.qualifier, type.charOffset, type.fileUri), |
| nameOrQualified.name); |
| library.addProblem(message, type.charOffset, |
| nameOrQualified.endCharOffset - type.charOffset, type.fileUri); |
| builder.bind(builder.buildInvalidTypeDeclarationBuilder( |
| message.withLocation(type.fileUri, type.charOffset, |
| nameOrQualified.endCharOffset - type.charOffset))); |
| } else { |
| scope ??= toScope(null).withTypeVariables(typeVariables); |
| type.resolveIn(scope, library); |
| } |
| } |
| types.clear(); |
| } |
| |
| Scope toScope(Scope parent) { |
| return new Scope( |
| local: members, |
| setters: setters, |
| extensions: extensions, |
| parent: parent, |
| debugName: name, |
| isModifiable: false); |
| } |
| |
| @override |
| String toString() => 'DeclarationBuilder(${hashCode}:kind=$kind,name=$name)'; |
| } |
| |
| class FieldInfo { |
| final String name; |
| final int charOffset; |
| final Token initializerToken; |
| final Token beforeLast; |
| final int charEndOffset; |
| |
| const FieldInfo(this.name, this.charOffset, this.initializerToken, |
| this.beforeLast, this.charEndOffset); |
| } |
| |
| class ImplementationInfo { |
| final String name; |
| final Builder declaration; |
| final int charOffset; |
| |
| const ImplementationInfo(this.name, this.declaration, this.charOffset); |
| } |
| |
| Uri computeLibraryUri(Builder declaration) { |
| Builder current = declaration; |
| do { |
| if (current is LibraryBuilder) return current.importUri; |
| current = current.parent; |
| } while (current != null); |
| return unhandled("no library parent", "${declaration.runtimeType}", |
| declaration.charOffset, declaration.fileUri); |
| } |
| |
| String extractName(name) => name is QualifiedName ? name.name : name; |
| |
| class PostponedProblem { |
| final Message message; |
| final int charOffset; |
| final int length; |
| final Uri fileUri; |
| |
| PostponedProblem(this.message, this.charOffset, this.length, this.fileUri); |
| } |
| |
| class LanguageVersion { |
| final Version version; |
| final Uri fileUri; |
| final int charOffset; |
| final int charCount; |
| final bool isExplicit; |
| bool isFinal = false; |
| |
| LanguageVersion(this.version, this.fileUri, this.charOffset, this.charCount, |
| this.isExplicit); |
| |
| bool get valid => true; |
| |
| int get hashCode => version.hashCode * 13 + isExplicit.hashCode * 19; |
| |
| bool operator ==(Object other) { |
| if (identical(this, other)) return true; |
| return other is LanguageVersion && |
| version == other.version && |
| isExplicit == other.isExplicit; |
| } |
| |
| String toString() { |
| return 'LanguageVersion(version=$version,isExplicit=$isExplicit,' |
| 'fileUri=$fileUri,charOffset=$charOffset,charCount=$charCount)'; |
| } |
| } |
| |
| class InvalidLanguageVersion implements LanguageVersion { |
| final Uri fileUri; |
| final int charOffset; |
| final int charCount; |
| final bool isExplicit; |
| final Version version; |
| bool isFinal = false; |
| |
| InvalidLanguageVersion(this.fileUri, this.charOffset, this.charCount, |
| this.isExplicit, this.version); |
| |
| @override |
| bool get valid => false; |
| |
| int get hashCode => isExplicit.hashCode * 19; |
| |
| bool operator ==(Object other) { |
| if (identical(this, other)) return true; |
| return other is InvalidLanguageVersion && isExplicit == other.isExplicit; |
| } |
| |
| String toString() { |
| return 'InvalidLanguageVersion(isExplicit=$isExplicit,' |
| 'fileUri=$fileUri,charOffset=$charOffset,charCount=$charCount)'; |
| } |
| } |
| |
| class ImplicitLanguageVersion implements LanguageVersion { |
| @override |
| final Version version; |
| bool isFinal = false; |
| |
| ImplicitLanguageVersion(this.version); |
| |
| @override |
| bool get valid => true; |
| |
| @override |
| Uri get fileUri => null; |
| |
| @override |
| int get charOffset => -1; |
| |
| @override |
| int get charCount => noLength; |
| |
| @override |
| bool get isExplicit => false; |
| |
| bool operator ==(Object other) { |
| if (identical(this, other)) return true; |
| return other is ImplicitLanguageVersion && version == other.version; |
| } |
| |
| @override |
| String toString() { |
| return 'ImplicitLanguageVersion(version=$version)'; |
| } |
| } |