| Index: pkg/compiler/lib/src/elements/modelx.dart
|
| diff --git a/pkg/compiler/lib/src/elements/modelx.dart b/pkg/compiler/lib/src/elements/modelx.dart
|
| deleted file mode 100644
|
| index d435f4aa9c96e0acd7784ba785f71ee035330c3b..0000000000000000000000000000000000000000
|
| --- a/pkg/compiler/lib/src/elements/modelx.dart
|
| +++ /dev/null
|
| @@ -1,2721 +0,0 @@
|
| -// Copyright (c) 2013, 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 elements.modelx;
|
| -
|
| -import 'elements.dart';
|
| -import '../constants/expressions.dart';
|
| -import '../helpers/helpers.dart'; // Included for debug helpers.
|
| -import '../tree/tree.dart';
|
| -import '../util/util.dart';
|
| -import '../resolution/resolution.dart';
|
| -import '../resolution/class_members.dart' show ClassMemberMixin;
|
| -
|
| -import '../dart2jslib.dart' show invariant,
|
| - InterfaceType,
|
| - DartType,
|
| - TypeVariableType,
|
| - TypedefType,
|
| - DualKind,
|
| - MessageKind,
|
| - DiagnosticListener,
|
| - Script,
|
| - FunctionType,
|
| - Selector,
|
| - Constant,
|
| - Compiler,
|
| - Backend,
|
| - isPrivateName;
|
| -
|
| -import '../dart_types.dart';
|
| -
|
| -import '../scanner/scannerlib.dart' show
|
| - EOF_TOKEN,
|
| - ErrorToken,
|
| - Token;
|
| -
|
| -import '../ordered_typeset.dart' show OrderedTypeSet;
|
| -
|
| -import 'visitor.dart' show ElementVisitor;
|
| -
|
| -abstract class DeclarationSite {
|
| -}
|
| -
|
| -abstract class ElementX extends Element {
|
| - static int elementHashCode = 0;
|
| -
|
| - final String name;
|
| - final ElementKind kind;
|
| - final Element enclosingElement;
|
| - final int hashCode = ++elementHashCode;
|
| - Link<MetadataAnnotation> metadata = const Link<MetadataAnnotation>();
|
| -
|
| - ElementX(this.name, this.kind, this.enclosingElement) {
|
| - assert(isErroneous || implementationLibrary != null);
|
| - }
|
| -
|
| - Modifiers get modifiers => Modifiers.EMPTY;
|
| -
|
| - Node parseNode(DiagnosticListener listener) {
|
| - listener.internalError(this,
|
| - 'parseNode not implemented on $this.');
|
| - return null;
|
| - }
|
| -
|
| - DartType computeType(Compiler compiler) {
|
| - compiler.internalError(this,
|
| - "computeType not implemented on $this.");
|
| - return null;
|
| - }
|
| -
|
| - void addMetadata(MetadataAnnotationX annotation) {
|
| - assert(annotation.annotatedElement == null);
|
| - annotation.annotatedElement = this;
|
| - addMetadataInternal(annotation);
|
| - }
|
| -
|
| - void addMetadataInternal(MetadataAnnotation annotation) {
|
| - metadata = metadata.prepend(annotation);
|
| - }
|
| -
|
| - bool get isClosure => false;
|
| - bool get isClassMember {
|
| - // Check that this element is defined in the scope of a Class.
|
| - return enclosingElement != null && enclosingElement.isClass;
|
| - }
|
| - bool get isInstanceMember => false;
|
| - bool get isDeferredLoaderGetter => false;
|
| -
|
| - bool get isFactoryConstructor => modifiers.isFactory;
|
| - bool get isConst => modifiers.isConst;
|
| - bool get isFinal => modifiers.isFinal;
|
| - bool get isStatic => modifiers.isStatic;
|
| - bool get isOperator => Elements.isOperatorName(name);
|
| - bool get impliesType => (kind.category & ElementCategory.IMPLIES_TYPE) != 0;
|
| -
|
| - bool get isPatched => false;
|
| -
|
| - bool get isPatch => false;
|
| -
|
| - bool get isImplementation => true;
|
| -
|
| - bool get isDeclaration => true;
|
| -
|
| - bool get isInjected => !isPatch && implementationLibrary.isPatch;
|
| -
|
| - Element get implementation => this;
|
| -
|
| - Element get declaration => this;
|
| -
|
| - Element get patch {
|
| - throw new UnsupportedError('patch is not supported on $this');
|
| - }
|
| -
|
| - Element get origin {
|
| - throw new UnsupportedError('origin is not supported on $this');
|
| - }
|
| -
|
| - bool get isSynthesized => false;
|
| -
|
| - bool get isForwardingConstructor => false;
|
| -
|
| - bool get isMixinApplication => false;
|
| -
|
| - bool get isLocal => false;
|
| -
|
| - // TODO(johnniwinther): This breaks for libraries (for which enclosing
|
| - // elements are null) and is invalid for top level variable declarations for
|
| - // which the enclosing element is a VariableDeclarations and not a compilation
|
| - // unit.
|
| - bool get isTopLevel {
|
| - return enclosingElement != null && enclosingElement.isCompilationUnit;
|
| - }
|
| -
|
| - bool get isAssignable {
|
| - if (isFinal || isConst) return false;
|
| - if (isFunction || isGenerativeConstructor) return false;
|
| - return true;
|
| - }
|
| -
|
| - Token get position => null;
|
| -
|
| - Token findMyName(Token token) {
|
| - return findNameToken(token, isConstructor, name, enclosingElement.name);
|
| - }
|
| -
|
| - static Token findNameToken(Token token, bool isConstructor, String name,
|
| - String enclosingClassName) {
|
| - // We search for the token that has the name of this element.
|
| - // For constructors, that doesn't work because they may have
|
| - // named formed out of multiple tokens (named constructors) so
|
| - // for those we search for the class name instead.
|
| - String needle = isConstructor ? enclosingClassName : name;
|
| - // The unary '-' operator has a special element name (specified).
|
| - if (needle == 'unary-') needle = '-';
|
| - for (Token t = token; EOF_TOKEN != t.kind; t = t.next) {
|
| - if (t is !ErrorToken && needle == t.value) return t;
|
| - }
|
| - return token;
|
| - }
|
| -
|
| - CompilationUnitElement get compilationUnit {
|
| - Element element = this;
|
| - while (!element.isCompilationUnit) {
|
| - element = element.enclosingElement;
|
| - }
|
| - return element;
|
| - }
|
| -
|
| - LibraryElement get library => enclosingElement.library;
|
| -
|
| - LibraryElement get implementationLibrary {
|
| - Element element = this;
|
| - while (!identical(element.kind, ElementKind.LIBRARY)) {
|
| - element = element.enclosingElement;
|
| - }
|
| - return element;
|
| - }
|
| -
|
| - ClassElement get enclosingClass {
|
| - for (Element e = this; e != null; e = e.enclosingElement) {
|
| - if (e.isClass) return e;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - Element get enclosingClassOrCompilationUnit {
|
| - for (Element e = this; e != null; e = e.enclosingElement) {
|
| - if (e.isClass || e.isCompilationUnit) return e;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - Element get outermostEnclosingMemberOrTopLevel {
|
| - // TODO(lrn): Why is this called "Outermost"?
|
| - // TODO(johnniwinther): Clean up this method: This method does not return
|
| - // the outermost for elements in closure classses, but some call-sites rely
|
| - // on that behavior.
|
| - for (Element e = this; e != null; e = e.enclosingElement) {
|
| - if (e.isClassMember || e.isTopLevel) {
|
| - return e;
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - ClassElement get contextClass {
|
| - ClassElement cls;
|
| - for (Element e = this; e != null; e = e.enclosingElement) {
|
| - if (e.isClass) {
|
| - // Record [e] instead of returning it directly. We need the last class
|
| - // in the chain since the first classes might be closure classes.
|
| - cls = e.declaration;
|
| - }
|
| - }
|
| - return cls;
|
| - }
|
| -
|
| - /**
|
| - * Creates the scope for this element.
|
| - */
|
| - Scope buildScope() => enclosingElement.buildScope();
|
| -
|
| - String toString() {
|
| - // TODO(johnniwinther): Test for nullness of name, or make non-nullness an
|
| - // invariant for all element types?
|
| - var nameText = name != null ? name : '?';
|
| - if (enclosingElement != null && !isTopLevel) {
|
| - String holderName = enclosingElement.name != null
|
| - ? enclosingElement.name
|
| - : '${enclosingElement.kind}?';
|
| - return '$kind($holderName#${nameText})';
|
| - } else {
|
| - return '$kind(${nameText})';
|
| - }
|
| - }
|
| -
|
| - String _fixedBackendName = null;
|
| - bool _isNative = false;
|
| - bool get isNative => _isNative;
|
| - bool get hasFixedBackendName => _fixedBackendName != null;
|
| - String get fixedBackendName => _fixedBackendName;
|
| - // Marks this element as a native element.
|
| - void setNative(String name) {
|
| - _isNative = true;
|
| - _fixedBackendName = name;
|
| - }
|
| - void setFixedBackendName(String name) {
|
| - _fixedBackendName = name;
|
| - }
|
| -
|
| - FunctionElement asFunctionElement() => null;
|
| -
|
| - bool get isAbstract => modifiers.isAbstract;
|
| - bool isForeign(Backend backend) => backend.isForeign(this);
|
| -
|
| - void diagnose(Element context, DiagnosticListener listener) {}
|
| -
|
| - bool get hasTreeElements => analyzableElement.hasTreeElements;
|
| -
|
| - TreeElements get treeElements => analyzableElement.treeElements;
|
| -
|
| - AnalyzableElement get analyzableElement {
|
| - Element element = outermostEnclosingMemberOrTopLevel;
|
| - if (element.isAbstractField || element.isPrefix) return element.library;
|
| - return element;
|
| - }
|
| -
|
| - DeclarationSite get declarationSite => null;
|
| -}
|
| -
|
| -class ErroneousElementX extends ElementX implements ErroneousElement {
|
| - final MessageKind messageKind;
|
| - final Map messageArguments;
|
| -
|
| - ErroneousElementX(this.messageKind, this.messageArguments,
|
| - String name, Element enclosing)
|
| - : super(name, ElementKind.ERROR, enclosing);
|
| -
|
| - bool get isTopLevel => false;
|
| -
|
| - bool get isSynthesized => true;
|
| -
|
| - AbstractFieldElement abstractField;
|
| -
|
| - unsupported() {
|
| - throw 'unsupported operation on erroneous element';
|
| - }
|
| -
|
| - get asyncMarker => AsyncMarker.SYNC;
|
| - Link<MetadataAnnotation> get metadata => unsupported();
|
| - bool get hasNode => false;
|
| - get node => unsupported();
|
| - get hasResolvedAst => false;
|
| - get resolvedAst => unsupported();
|
| - get type => unsupported();
|
| - get cachedNode => unsupported();
|
| - get functionSignature => unsupported();
|
| - get patch => null;
|
| - get origin => this;
|
| - get immediateRedirectionTarget => unsupported();
|
| - get nestedClosures => unsupported();
|
| - get memberContext => unsupported();
|
| - get executableContext => unsupported();
|
| -
|
| - bool get isRedirectingFactory => unsupported();
|
| -
|
| - computeSignature(compiler) => unsupported();
|
| -
|
| - bool get hasFunctionSignature => false;
|
| -
|
| - get effectiveTarget => this;
|
| -
|
| - computeEffectiveTargetType(InterfaceType newType) => unsupported();
|
| -
|
| - get definingConstructor => null;
|
| -
|
| - FunctionElement asFunctionElement() => this;
|
| -
|
| - String get message => '${messageKind.message(messageArguments)}';
|
| -
|
| - String toString() => '<$name: $message>';
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitErroneousElement(this);
|
| -}
|
| -
|
| -/// A message attached to a [WarnOnUseElementX].
|
| -class WrappedMessage {
|
| - /// The message position. If [:null:] the position of the reference to the
|
| - /// [WarnOnUseElementX] is used.
|
| - final Spannable spannable;
|
| -
|
| - /**
|
| - * The message to report on resolving a wrapped element.
|
| - */
|
| - final MessageKind messageKind;
|
| -
|
| - /**
|
| - * The message arguments to report on resolving a wrapped element.
|
| - */
|
| - final Map messageArguments;
|
| -
|
| - WrappedMessage(this.spannable, this.messageKind, this.messageArguments);
|
| -}
|
| -
|
| -class WarnOnUseElementX extends ElementX implements WarnOnUseElement {
|
| - /// Warning to report on resolving this element.
|
| - final WrappedMessage warning;
|
| -
|
| - /// Info to report on resolving this element.
|
| - final WrappedMessage info;
|
| -
|
| - /// The element whose usage cause a warning.
|
| - final Element wrappedElement;
|
| -
|
| - WarnOnUseElementX(WrappedMessage this.warning, WrappedMessage this.info,
|
| - Element enclosingElement, Element wrappedElement)
|
| - : this.wrappedElement = wrappedElement,
|
| - super(wrappedElement.name, ElementKind.WARN_ON_USE, enclosingElement);
|
| -
|
| - Element unwrap(DiagnosticListener listener, Spannable usageSpannable) {
|
| - var unwrapped = wrappedElement;
|
| - if (warning != null) {
|
| - Spannable spannable = warning.spannable;
|
| - if (spannable == null) spannable = usageSpannable;
|
| - listener.reportWarning(
|
| - spannable, warning.messageKind, warning.messageArguments);
|
| - }
|
| - if (info != null) {
|
| - Spannable spannable = info.spannable;
|
| - if (spannable == null) spannable = usageSpannable;
|
| - listener.reportInfo(
|
| - spannable, info.messageKind, info.messageArguments);
|
| - }
|
| - if (unwrapped.isWarnOnUse) {
|
| - unwrapped = unwrapped.unwrap(listener, usageSpannable);
|
| - }
|
| - return unwrapped;
|
| - }
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitWarnOnUseElement(this);
|
| -}
|
| -
|
| -class AmbiguousElementX extends ElementX implements AmbiguousElement {
|
| - /**
|
| - * The message to report on resolving this element.
|
| - */
|
| - final MessageKind messageKind;
|
| -
|
| - /**
|
| - * The message arguments to report on resolving this element.
|
| - */
|
| - final Map messageArguments;
|
| -
|
| - /**
|
| - * The first element that this ambiguous element might refer to.
|
| - */
|
| - final Element existingElement;
|
| -
|
| - /**
|
| - * The second element that this ambiguous element might refer to.
|
| - */
|
| - final Element newElement;
|
| -
|
| - AmbiguousElementX(this.messageKind, this.messageArguments,
|
| - Element enclosingElement, Element existingElement, Element newElement)
|
| - : this.existingElement = existingElement,
|
| - this.newElement = newElement,
|
| - super(existingElement.name, ElementKind.AMBIGUOUS, enclosingElement);
|
| -
|
| - Setlet flatten() {
|
| - Element element = this;
|
| - var set = new Setlet();
|
| - while (element.isAmbiguous) {
|
| - AmbiguousElement ambiguous = element;
|
| - set.add(ambiguous.newElement);
|
| - element = ambiguous.existingElement;
|
| - }
|
| - set.add(element);
|
| - return set;
|
| - }
|
| -
|
| - void diagnose(Element context, DiagnosticListener listener) {
|
| - Setlet ambiguousElements = flatten();
|
| - MessageKind code = (ambiguousElements.length == 1)
|
| - ? MessageKind.AMBIGUOUS_REEXPORT : MessageKind.AMBIGUOUS_LOCATION;
|
| - LibraryElementX importer = context.library;
|
| - for (Element element in ambiguousElements) {
|
| - var arguments = {'name': element.name};
|
| - listener.reportInfo(element, code, arguments);
|
| - Link<Import> importers = importer.importers.getImports(element);
|
| - listener.withCurrentElement(importer, () {
|
| - for (; !importers.isEmpty; importers = importers.tail) {
|
| - listener.reportInfo(
|
| - importers.head, MessageKind.IMPORTED_HERE, arguments);
|
| - }
|
| - });
|
| - }
|
| - }
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitAmbiguousElement(this);
|
| -
|
| - bool get isTopLevel => false;
|
| -}
|
| -
|
| -class ScopeX {
|
| - final Map<String, Element> contents = new Map<String, Element>();
|
| -
|
| - bool get isEmpty => contents.isEmpty;
|
| - Iterable<Element> get values => contents.values;
|
| -
|
| - Element lookup(String name) {
|
| - return contents[name];
|
| - }
|
| -
|
| - void add(Element element, DiagnosticListener listener) {
|
| - String name = element.name;
|
| - if (element.isAccessor) {
|
| - addAccessor(element, contents[name], listener);
|
| - } else {
|
| - Element existing = contents.putIfAbsent(name, () => element);
|
| - if (!identical(existing, element)) {
|
| - listener.reportError(
|
| - element, MessageKind.DUPLICATE_DEFINITION, {'name': name});
|
| - listener.reportInfo(existing,
|
| - MessageKind.EXISTING_DEFINITION, {'name': name});
|
| - }
|
| - }
|
| - }
|
| -
|
| - /**
|
| - * Adds a definition for an [accessor] (getter or setter) to a scope.
|
| - * The definition binds to an abstract field that can hold both a getter
|
| - * and a setter.
|
| - *
|
| - * The abstract field is added once, for the first getter or setter, and
|
| - * reused if the other one is also added.
|
| - * The abstract field should not be treated as a proper member of the
|
| - * container, it's simply a way to return two results for one lookup.
|
| - * That is, the getter or setter does not have the abstract field as enclosing
|
| - * element, they are enclosed by the class or compilation unit, as is the
|
| - * abstract field.
|
| - */
|
| - void addAccessor(FunctionElementX accessor,
|
| - Element existing,
|
| - DiagnosticListener listener) {
|
| - void reportError(Element other) {
|
| - listener.reportError(accessor,
|
| - MessageKind.DUPLICATE_DEFINITION,
|
| - {'name': accessor.name});
|
| - // TODO(johnniwinther): Make this an info instead of a fatal error.
|
| - listener.reportFatalError(other,
|
| - MessageKind.EXISTING_DEFINITION,
|
| - {'name': accessor.name});
|
| - }
|
| -
|
| - if (existing != null) {
|
| - if (!identical(existing.kind, ElementKind.ABSTRACT_FIELD)) {
|
| - reportError(existing);
|
| - } else {
|
| - AbstractFieldElementX field = existing;
|
| - accessor.abstractField = field;
|
| - if (accessor.isGetter) {
|
| - if (field.getter != null && field.getter != accessor) {
|
| - reportError(field.getter);
|
| - }
|
| - field.getter = accessor;
|
| - } else {
|
| - assert(accessor.isSetter);
|
| - if (field.setter != null && field.setter != accessor) {
|
| - reportError(field.setter);
|
| - }
|
| - field.setter = accessor;
|
| - }
|
| - }
|
| - } else {
|
| - Element container = accessor.enclosingClassOrCompilationUnit;
|
| - AbstractFieldElementX field =
|
| - new AbstractFieldElementX(accessor.name, container);
|
| - accessor.abstractField = field;
|
| - if (accessor.isGetter) {
|
| - field.getter = accessor;
|
| - } else {
|
| - field.setter = accessor;
|
| - }
|
| - add(field, listener);
|
| - }
|
| - }
|
| -}
|
| -
|
| -class CompilationUnitElementX extends ElementX
|
| - implements CompilationUnitElement {
|
| - final Script script;
|
| - PartOf partTag;
|
| - Link<Element> localMembers = const Link<Element>();
|
| -
|
| - CompilationUnitElementX(Script script, LibraryElement library)
|
| - : this.script = script,
|
| - super(script.name,
|
| - ElementKind.COMPILATION_UNIT,
|
| - library) {
|
| - library.addCompilationUnit(this);
|
| - }
|
| -
|
| - void forEachLocalMember(f(Element element)) {
|
| - localMembers.forEach(f);
|
| - }
|
| -
|
| - void addMember(Element element, DiagnosticListener listener) {
|
| - // Keep a list of top level members.
|
| - localMembers = localMembers.prepend(element);
|
| - // Provide the member to the library to build scope.
|
| - if (enclosingElement.isPatch) {
|
| - implementationLibrary.addMember(element, listener);
|
| - } else {
|
| - library.addMember(element, listener);
|
| - }
|
| - }
|
| -
|
| - void setPartOf(PartOf tag, DiagnosticListener listener) {
|
| - LibraryElementX library = enclosingElement;
|
| - if (library.entryCompilationUnit == this) {
|
| - listener.reportError(tag, MessageKind.ILLEGAL_DIRECTIVE);
|
| - return;
|
| - }
|
| - if (!localMembers.isEmpty) {
|
| - listener.reportError(tag, MessageKind.BEFORE_TOP_LEVEL);
|
| - return;
|
| - }
|
| - if (partTag != null) {
|
| - listener.reportWarning(tag, MessageKind.DUPLICATED_PART_OF);
|
| - return;
|
| - }
|
| - partTag = tag;
|
| - LibraryName libraryTag = library.libraryTag;
|
| - String actualName = tag.name.toString();
|
| - if (libraryTag != null) {
|
| - String expectedName = libraryTag.name.toString();
|
| - if (expectedName != actualName) {
|
| - listener.reportWarning(tag.name,
|
| - MessageKind.LIBRARY_NAME_MISMATCH,
|
| - {'libraryName': expectedName});
|
| - }
|
| - } else {
|
| - listener.reportWarning(library,
|
| - MessageKind.MISSING_LIBRARY_NAME,
|
| - {'libraryName': actualName});
|
| - listener.reportInfo(tag.name,
|
| - MessageKind.THIS_IS_THE_PART_OF_TAG);
|
| - }
|
| - }
|
| -
|
| - bool get hasMembers => !localMembers.isEmpty;
|
| -
|
| - int compareTo(CompilationUnitElement other) {
|
| - if (this == other) return 0;
|
| - return '${script.readableUri}'.compareTo('${other.script.readableUri}');
|
| - }
|
| -
|
| - Element get analyzableElement => library;
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
|
| -}
|
| -
|
| -class Importers {
|
| - Map<Element, Link<Import>> importers = new Map<Element, Link<Import>>();
|
| -
|
| - Link<Import> getImports(Element element) {
|
| - Link<Import> imports = importers[element];
|
| - return imports != null ? imports : const Link<Import>();
|
| - }
|
| -
|
| - Import getImport(Element element) => getImports(element).head;
|
| -
|
| - void registerImport(Element element, Import import) {
|
| - if (import == null) return;
|
| -
|
| - importers[element] =
|
| - importers.putIfAbsent(element, () => const Link<Import>())
|
| - .prepend(import);
|
| - }
|
| -}
|
| -
|
| -class ImportScope {
|
| - /**
|
| - * Map for elements imported through import declarations.
|
| - *
|
| - * Addition to the map is performed by [addImport]. Lookup is done trough
|
| - * [find].
|
| - */
|
| - final Map<String, Element> importScope =
|
| - new Map<String, Element>();
|
| -
|
| - /**
|
| - * Adds [element] to the import scope of this library.
|
| - *
|
| - * If an element by the same name is already in the imported scope, an
|
| - * [ErroneousElement] will be put in the imported scope, allowing for
|
| - * detection of ambiguous uses of imported names.
|
| - */
|
| - void addImport(Element enclosingElement,
|
| - Element element,
|
| - Import import,
|
| - DiagnosticListener listener) {
|
| - LibraryElementX library = enclosingElement.library;
|
| - Importers importers = library.importers;
|
| -
|
| - String name = element.name;
|
| -
|
| - // The loadLibrary function always shadows existing bindings to that name.
|
| - if (element.isDeferredLoaderGetter) {
|
| - importScope.remove(name);
|
| - // TODO(sigurdm): Print a hint.
|
| - }
|
| - Element existing = importScope.putIfAbsent(name, () => element);
|
| - importers.registerImport(element, import);
|
| -
|
| - void registerWarnOnUseElement(Import import,
|
| - MessageKind messageKind,
|
| - Element hidingElement,
|
| - Element hiddenElement) {
|
| - Uri hiddenUri = hiddenElement.library.canonicalUri;
|
| - Uri hidingUri = hidingElement.library.canonicalUri;
|
| - Element element = new WarnOnUseElementX(
|
| - new WrappedMessage(
|
| - null, // Report on reference to [hidingElement].
|
| - messageKind,
|
| - {'name': name, 'hiddenUri': hiddenUri, 'hidingUri': hidingUri}),
|
| - new WrappedMessage(
|
| - listener.spanFromSpannable(import),
|
| - MessageKind.IMPORTED_HERE,
|
| - {'name': name}),
|
| - enclosingElement, hidingElement);
|
| - importScope[name] = element;
|
| - importers.registerImport(element, import);
|
| - }
|
| -
|
| - if (existing != element) {
|
| - Import existingImport = importers.getImport(existing);
|
| - Element newElement;
|
| - if (existing.library.isPlatformLibrary &&
|
| - !element.library.isPlatformLibrary) {
|
| - // [existing] is implicitly hidden.
|
| - registerWarnOnUseElement(
|
| - import, MessageKind.HIDDEN_IMPORT, element, existing);
|
| - } else if (!existing.library.isPlatformLibrary &&
|
| - element.library.isPlatformLibrary) {
|
| - // [element] is implicitly hidden.
|
| - if (import == null) {
|
| - // [element] is imported implicitly (probably through dart:core).
|
| - registerWarnOnUseElement(
|
| - existingImport, MessageKind.HIDDEN_IMPLICIT_IMPORT,
|
| - existing, element);
|
| - } else {
|
| - registerWarnOnUseElement(
|
| - import, MessageKind.HIDDEN_IMPORT, existing, element);
|
| - }
|
| - } else {
|
| - Element ambiguousElement = new AmbiguousElementX(
|
| - MessageKind.DUPLICATE_IMPORT, {'name': name},
|
| - enclosingElement, existing, element);
|
| - importScope[name] = ambiguousElement;
|
| - importers.registerImport(ambiguousElement, import);
|
| - importers.registerImport(ambiguousElement, existingImport);
|
| - }
|
| - }
|
| - }
|
| -
|
| - Element operator [](String name) => importScope[name];
|
| -}
|
| -
|
| -class LibraryElementX
|
| - extends ElementX with AnalyzableElementX, PatchMixin<LibraryElementX>
|
| - implements LibraryElement {
|
| - final Uri canonicalUri;
|
| - CompilationUnitElement entryCompilationUnit;
|
| - Link<CompilationUnitElement> compilationUnits =
|
| - const Link<CompilationUnitElement>();
|
| - LinkBuilder<LibraryTag> tagsBuilder = new LinkBuilder<LibraryTag>();
|
| - List<LibraryTag> tagsCache;
|
| - LibraryName libraryTag;
|
| - bool canUseNative = false;
|
| - Link<Element> localMembers = const Link<Element>();
|
| - final ScopeX localScope = new ScopeX();
|
| - final ImportScope importScope = new ImportScope();
|
| -
|
| - /// A mapping from an imported element to the "import" tag.
|
| - final Importers importers = new Importers();
|
| -
|
| - /**
|
| - * Link for elements exported either through export declarations or through
|
| - * declaration. This field should not be accessed directly but instead through
|
| - * the [exports] getter.
|
| - *
|
| - * [LibraryDependencyHandler] sets this field through [setExports] when the
|
| - * library is loaded.
|
| - */
|
| - Link<Element> slotForExports;
|
| -
|
| - final Map<LibraryDependency, LibraryElement> tagMapping =
|
| - new Map<LibraryDependency, LibraryElement>();
|
| -
|
| - LibraryElementX(Script script,
|
| - [Uri canonicalUri, LibraryElementX origin])
|
| - : this.canonicalUri =
|
| - ((canonicalUri == null) ? script.readableUri : canonicalUri),
|
| - super(script.name, ElementKind.LIBRARY, null) {
|
| - entryCompilationUnit = new CompilationUnitElementX(script, this);
|
| - if (origin != null) {
|
| - origin.applyPatch(this);
|
| - }
|
| - }
|
| -
|
| - bool get isDartCore => canonicalUri == Compiler.DART_CORE;
|
| -
|
| - Link<MetadataAnnotation> get metadata {
|
| - return (libraryTag == null) ? super.metadata : libraryTag.metadata;
|
| - }
|
| -
|
| - set metadata(value) {
|
| - // The metadata is stored on [libraryTag].
|
| - throw new SpannableAssertionFailure(this, 'Cannot set metadata on Library');
|
| - }
|
| -
|
| - CompilationUnitElement get compilationUnit => entryCompilationUnit;
|
| -
|
| - Element get analyzableElement => this;
|
| -
|
| - void addCompilationUnit(CompilationUnitElement element) {
|
| - compilationUnits = compilationUnits.prepend(element);
|
| - }
|
| -
|
| - void addTag(LibraryTag tag, DiagnosticListener listener) {
|
| - if (tagsCache != null) {
|
| - listener.internalError(tag,
|
| - "Library tags for $this have already been computed.");
|
| - }
|
| - tagsBuilder.addLast(tag);
|
| - }
|
| -
|
| - Iterable<LibraryTag> get tags {
|
| - if (tagsCache == null) {
|
| - tagsCache = tagsBuilder.toList();
|
| - tagsBuilder = null;
|
| - }
|
| - return tagsCache;
|
| - }
|
| -
|
| - void recordResolvedTag(LibraryDependency tag, LibraryElement library) {
|
| - assert(tagMapping[tag] == null);
|
| - tagMapping[tag] = library;
|
| - }
|
| -
|
| - LibraryElement getLibraryFromTag(LibraryDependency tag) => tagMapping[tag];
|
| -
|
| - /**
|
| - * Adds [element] to the import scope of this library.
|
| - *
|
| - * If an element by the same name is already in the imported scope, an
|
| - * [ErroneousElement] will be put in the imported scope, allowing for
|
| - * detection of ambiguous uses of imported names.
|
| - */
|
| - void addImport(Element element, Import import, DiagnosticListener listener) {
|
| - importScope.addImport(this, element, import, listener);
|
| - }
|
| -
|
| - void addMember(Element element, DiagnosticListener listener) {
|
| - localMembers = localMembers.prepend(element);
|
| - addToScope(element, listener);
|
| - }
|
| -
|
| - void addToScope(Element element, DiagnosticListener listener) {
|
| - localScope.add(element, listener);
|
| - }
|
| -
|
| - Element localLookup(String elementName) {
|
| - Element result = localScope.lookup(elementName);
|
| - if (result == null && isPatch) {
|
| - result = origin.localLookup(elementName);
|
| - }
|
| - return result;
|
| - }
|
| -
|
| - /**
|
| - * Returns [:true:] if the export scope has already been computed for this
|
| - * library.
|
| - */
|
| - bool get exportsHandled => slotForExports != null;
|
| -
|
| - Link<Element> get exports {
|
| - assert(invariant(this, exportsHandled,
|
| - message: 'Exports not handled on $this'));
|
| - return slotForExports;
|
| - }
|
| -
|
| - /**
|
| - * Sets the export scope of this library. This method can only be called once.
|
| - */
|
| - void setExports(Iterable<Element> exportedElements) {
|
| - assert(invariant(this, !exportsHandled,
|
| - message: 'Exports already set to $slotForExports on $this'));
|
| - assert(invariant(this, exportedElements != null));
|
| - var builder = new LinkBuilder<Element>();
|
| - for (Element export in exportedElements) {
|
| - builder.addLast(export);
|
| - }
|
| - slotForExports = builder.toLink();
|
| - }
|
| -
|
| - LibraryElement get library => isPatch ? origin : this;
|
| -
|
| - /**
|
| - * Look up a top-level element in this library. The element could
|
| - * potentially have been imported from another library. Returns
|
| - * null if no such element exist and an [ErroneousElement] if multiple
|
| - * elements have been imported.
|
| - */
|
| - Element find(String elementName) {
|
| - Element result = localScope.lookup(elementName);
|
| - if (result != null) return result;
|
| - if (origin != null) {
|
| - result = origin.localScope.lookup(elementName);
|
| - if (result != null) return result;
|
| - }
|
| - result = importScope[elementName];
|
| - if (result != null) return result;
|
| - if (origin != null) {
|
| - result = origin.importScope[elementName];
|
| - if (result != null) return result;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /** Look up a top-level element in this library, but only look for
|
| - * non-imported elements. Returns null if no such element exist. */
|
| - Element findLocal(String elementName) {
|
| - // TODO(johnniwinther): How to handle injected elements in the patch
|
| - // library?
|
| - Element result = localScope.lookup(elementName);
|
| - if (result == null || result.library != this) return null;
|
| - return result;
|
| - }
|
| -
|
| - Element findExported(String elementName) {
|
| - for (Link link = exports; !link.isEmpty; link = link.tail) {
|
| - Element element = link.head;
|
| - if (element.name == elementName) return element;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - void forEachExport(f(Element element)) {
|
| - exports.forEach((Element e) => f(e));
|
| - }
|
| -
|
| - Link<Import> getImportsFor(Element element) => importers.getImports(element);
|
| -
|
| - void forEachLocalMember(f(Element element)) {
|
| - if (isPatch) {
|
| - // Patch libraries traverse both origin and injected members.
|
| - origin.localMembers.forEach(f);
|
| -
|
| - void filterPatch(Element element) {
|
| - if (!element.isPatch) {
|
| - // Do not traverse the patch members.
|
| - f(element);
|
| - }
|
| - }
|
| - localMembers.forEach(filterPatch);
|
| - } else {
|
| - localMembers.forEach(f);
|
| - }
|
| - }
|
| -
|
| - Iterable<Element> getNonPrivateElementsInScope() {
|
| - return localScope.values.where((Element element) {
|
| - // At this point [localScope] only contains members so we don't need
|
| - // to check for foreign or prefix elements.
|
| - return !isPrivateName(element.name);
|
| - });
|
| - }
|
| -
|
| - bool hasLibraryName() => libraryTag != null;
|
| -
|
| - /**
|
| - * Returns the library name, which is either the name given in the library tag
|
| - * or the empty string if there is no library tag.
|
| - */
|
| - String getLibraryName() {
|
| - if (libraryTag == null) return '';
|
| - return libraryTag.name.toString();
|
| - }
|
| -
|
| - /**
|
| - * Returns the library name (as defined by the library tag) or for script
|
| - * (which have no library tag) the script file name. The latter case is used
|
| - * to private 'library name' for scripts to use for instance in dartdoc.
|
| - *
|
| - * Note: the returned filename will still be escaped ("a%20b.dart" instead of
|
| - * "a b.dart").
|
| - */
|
| - String getLibraryOrScriptName() {
|
| - if (libraryTag != null) {
|
| - return libraryTag.name.toString();
|
| - } else {
|
| - // Use the file name as script name.
|
| - String path = canonicalUri.path;
|
| - return path.substring(path.lastIndexOf('/') + 1);
|
| - }
|
| - }
|
| -
|
| - Scope buildScope() => new LibraryScope(this);
|
| -
|
| - bool get isPlatformLibrary => canonicalUri.scheme == 'dart';
|
| -
|
| - bool get isPackageLibrary => canonicalUri.scheme == 'package';
|
| -
|
| - bool get isInternalLibrary =>
|
| - isPlatformLibrary && canonicalUri.path.startsWith('_');
|
| -
|
| - String toString() {
|
| - if (origin != null) {
|
| - return 'patch library(${canonicalUri})';
|
| - } else if (patch != null) {
|
| - return 'origin library(${canonicalUri})';
|
| - } else {
|
| - return 'library(${canonicalUri})';
|
| - }
|
| - }
|
| -
|
| - int compareTo(LibraryElement other) {
|
| - if (this == other) return 0;
|
| - return getLibraryOrScriptName().compareTo(other.getLibraryOrScriptName());
|
| - }
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
|
| -
|
| - // TODO(johnniwinther): Remove these when issue 18630 is fixed.
|
| - LibraryElementX get patch => super.patch;
|
| - LibraryElementX get origin => super.origin;
|
| -}
|
| -
|
| -class PrefixElementX extends ElementX implements PrefixElement {
|
| - Token firstPosition;
|
| -
|
| - final ImportScope importScope = new ImportScope();
|
| -
|
| - bool get isDeferred => _deferredImport != null;
|
| -
|
| - // Only needed for deferred imports.
|
| - Import _deferredImport;
|
| - Import get deferredImport => _deferredImport;
|
| -
|
| - PrefixElementX(String prefix, Element enclosing, this.firstPosition)
|
| - : super(prefix, ElementKind.PREFIX, enclosing);
|
| -
|
| - bool get isTopLevel => false;
|
| -
|
| - Element lookupLocalMember(String memberName) => importScope[memberName];
|
| -
|
| - DartType computeType(Compiler compiler) => const DynamicType();
|
| -
|
| - Token get position => firstPosition;
|
| -
|
| - void addImport(Element element, Import import, DiagnosticListener listener) {
|
| - importScope.addImport(this, element, import, listener);
|
| - }
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
|
| -
|
| - void markAsDeferred(Import deferredImport) {
|
| - _deferredImport = deferredImport;
|
| - }
|
| -}
|
| -
|
| -class TypedefElementX extends ElementX
|
| - with AstElementMixin,
|
| - AnalyzableElementX,
|
| - TypeDeclarationElementX<TypedefType>
|
| - implements TypedefElement {
|
| - Typedef cachedNode;
|
| -
|
| - /**
|
| - * The type annotation which defines this typedef.
|
| - */
|
| - DartType alias;
|
| -
|
| - /// [:true:] if the typedef has been checked for cyclic reference.
|
| - bool hasBeenCheckedForCycles = false;
|
| -
|
| - int resolutionState = STATE_NOT_STARTED;
|
| -
|
| - TypedefElementX(String name, Element enclosing)
|
| - : super(name, ElementKind.TYPEDEF, enclosing);
|
| -
|
| - bool get hasNode => cachedNode != null;
|
| -
|
| - Typedef get node {
|
| - assert(invariant(this, cachedNode != null,
|
| - message: "Node has not been computed for $this."));
|
| - return cachedNode;
|
| - }
|
| -
|
| - /**
|
| - * Function signature for a typedef of a function type. The signature is
|
| - * kept to provide full information about parameter names through the mirror
|
| - * system.
|
| - *
|
| - * The [functionSignature] is not available until the typedef element has been
|
| - * resolved.
|
| - */
|
| - FunctionSignature functionSignature;
|
| -
|
| - TypedefType computeType(Compiler compiler) {
|
| - if (thisTypeCache != null) return thisTypeCache;
|
| - Typedef node = parseNode(compiler);
|
| - setThisAndRawTypes(compiler, createTypeVariables(node.typeParameters));
|
| - ensureResolved(compiler);
|
| - return thisTypeCache;
|
| - }
|
| -
|
| - void ensureResolved(Compiler compiler) {
|
| - if (resolutionState == STATE_NOT_STARTED) {
|
| - compiler.resolver.resolve(this);
|
| - }
|
| - }
|
| -
|
| - TypedefType createType(List<DartType> typeArguments) {
|
| - return new TypedefType(this, typeArguments);
|
| - }
|
| -
|
| - Scope buildScope() {
|
| - return new TypeDeclarationScope(enclosingElement.buildScope(), this);
|
| - }
|
| -
|
| - void checkCyclicReference(Compiler compiler) {
|
| - if (hasBeenCheckedForCycles) return;
|
| - var visitor = new TypedefCyclicVisitor(compiler, this);
|
| - computeType(compiler).accept(visitor, null);
|
| - hasBeenCheckedForCycles = true;
|
| - }
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitTypedefElement(this);
|
| -
|
| - // A typedef cannot be patched therefore defines itself.
|
| - AstElement get definingElement => this;
|
| -}
|
| -
|
| -// This class holds common information for a list of variable or field
|
| -// declarations. It contains the node, and the type. A [VariableElementX]
|
| -// forwards its [computeType] and [parseNode] methods to this class.
|
| -class VariableList implements DeclarationSite {
|
| - VariableDefinitions definitions;
|
| - DartType type;
|
| - final Modifiers modifiers;
|
| - Link<MetadataAnnotation> metadata = const Link<MetadataAnnotation>();
|
| -
|
| - VariableList(Modifiers this.modifiers);
|
| -
|
| - VariableList.node(VariableDefinitions node, this.type)
|
| - : this.definitions = node,
|
| - this.modifiers = node.modifiers {
|
| - assert(modifiers != null);
|
| - }
|
| -
|
| - VariableDefinitions parseNode(Element element, DiagnosticListener listener) {
|
| - return definitions;
|
| - }
|
| -
|
| - DartType computeType(Element element, Compiler compiler) => type;
|
| -}
|
| -
|
| -abstract class VariableElementX extends ElementX with AstElementMixin
|
| - implements VariableElement {
|
| - final Token token;
|
| - final VariableList variables;
|
| - VariableDefinitions definitionsCache;
|
| - Expression initializerCache;
|
| -
|
| - Modifiers get modifiers => variables.modifiers;
|
| -
|
| - VariableElementX(String name,
|
| - ElementKind kind,
|
| - Element enclosingElement,
|
| - VariableList variables,
|
| - this.token)
|
| - : this.variables = variables,
|
| - super(name, kind, enclosingElement);
|
| -
|
| - // TODO(johnniwinther): Ensure that the [TreeElements] for this variable hold
|
| - // the mappings for all its metadata.
|
| - Link<MetadataAnnotation> get metadata => variables.metadata;
|
| -
|
| - void addMetadataInternal(MetadataAnnotation annotation) {
|
| - variables.metadata = variables.metadata.prepend(annotation);
|
| - }
|
| -
|
| - // A variable cannot be patched therefore defines itself.
|
| - AstElement get definingElement => this;
|
| -
|
| - bool get hasNode => definitionsCache != null;
|
| -
|
| - VariableDefinitions get node {
|
| - assert(invariant(this, definitionsCache != null,
|
| - message: "Node has not been computed for $this."));
|
| - return definitionsCache;
|
| - }
|
| -
|
| - Expression get initializer {
|
| - assert(invariant(this, definitionsCache != null,
|
| - message: "Initializer has not been computed for $this."));
|
| - return initializerCache;
|
| - }
|
| -
|
| - Node parseNode(DiagnosticListener listener) {
|
| - if (definitionsCache != null) return definitionsCache;
|
| -
|
| - VariableDefinitions definitions = variables.parseNode(this, listener);
|
| - createDefinitions(definitions);
|
| - return definitionsCache;
|
| - }
|
| -
|
| - void createDefinitions(VariableDefinitions definitions) {
|
| - assert(invariant(this, definitionsCache == null,
|
| - message: "VariableDefinitions has already been computed for $this."));
|
| - Expression node;
|
| - int count = 0;
|
| - for (Link<Node> link = definitions.definitions.nodes;
|
| - !link.isEmpty; link = link.tail) {
|
| - Expression initializedIdentifier = link.head;
|
| - Identifier identifier = initializedIdentifier.asIdentifier();
|
| - if (identifier == null) {
|
| - SendSet sendSet = initializedIdentifier.asSendSet();
|
| - identifier = sendSet.selector.asIdentifier();
|
| - if (identical(name, identifier.source)) {
|
| - node = initializedIdentifier;
|
| - initializerCache = sendSet.arguments.first;
|
| - }
|
| - } else if (identical(name, identifier.source)) {
|
| - node = initializedIdentifier;
|
| - }
|
| - count++;
|
| - }
|
| - invariant(definitions, node != null, message: "Could not find '$name'.");
|
| - if (count == 1) {
|
| - definitionsCache = definitions;
|
| - } else {
|
| - // Create a [VariableDefinitions] node for the single definition of
|
| - // [node].
|
| - definitionsCache = new VariableDefinitions(definitions.type,
|
| - definitions.modifiers, new NodeList(
|
| - definitions.definitions.beginToken,
|
| - const Link<Node>().prepend(node),
|
| - definitions.definitions.endToken));
|
| - }
|
| - }
|
| -
|
| - DartType computeType(Compiler compiler) {
|
| - if (variables.type != null) return variables.type;
|
| - // Call [parseNode] to ensure that [definitionsCache] and [initializerCache]
|
| - // are set as a consequence of calling [computeType].
|
| - return compiler.withCurrentElement(this, () {
|
| - parseNode(compiler);
|
| - return variables.computeType(this, compiler);
|
| - });
|
| - }
|
| -
|
| - DartType get type {
|
| - assert(invariant(this, variables.type != null,
|
| - message: "Type has not been computed for $this."));
|
| - return variables.type;
|
| - }
|
| -
|
| - bool get isInstanceMember => isClassMember && !isStatic;
|
| -
|
| - // Note: cachedNode.beginToken will not be correct in all
|
| - // cases, for example, for function typed parameters.
|
| - Token get position => token;
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitVariableElement(this);
|
| -
|
| - DeclarationSite get declarationSite => variables;
|
| -}
|
| -
|
| -class LocalVariableElementX extends VariableElementX
|
| - implements LocalVariableElement {
|
| - LocalVariableElementX(String name,
|
| - ExecutableElement enclosingElement,
|
| - VariableList variables,
|
| - Token token)
|
| - : super(name, ElementKind.VARIABLE, enclosingElement, variables, token) {
|
| - createDefinitions(variables.definitions);
|
| - }
|
| -
|
| - ExecutableElement get executableContext => enclosingElement;
|
| -
|
| - ExecutableElement get memberContext => executableContext.memberContext;
|
| -
|
| - bool get isLocal => true;
|
| -}
|
| -
|
| -class FieldElementX extends VariableElementX
|
| - with AnalyzableElementX implements FieldElement {
|
| - List<FunctionElement> nestedClosures = new List<FunctionElement>();
|
| -
|
| - FieldElementX(Identifier name,
|
| - Element enclosingElement,
|
| - VariableList variables)
|
| - : super(name.source, ElementKind.FIELD, enclosingElement,
|
| - variables, name.token);
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
|
| -
|
| - MemberElement get memberContext => this;
|
| -
|
| - void reuseElement() {
|
| - super.reuseElement();
|
| - nestedClosures.clear();
|
| - }
|
| -}
|
| -
|
| -/// [Element] for a parameter-like element.
|
| -class FormalElementX extends ElementX
|
| - with AstElementMixin
|
| - implements FormalElement {
|
| - final VariableDefinitions definitions;
|
| - final Identifier identifier;
|
| - DartType typeCache;
|
| -
|
| - /**
|
| - * Function signature for a variable with a function type. The signature is
|
| - * kept to provide full information about parameter names through the mirror
|
| - * system.
|
| - */
|
| - FunctionSignature functionSignatureCache;
|
| -
|
| - FormalElementX(ElementKind elementKind,
|
| - FunctionTypedElement enclosingElement,
|
| - this.definitions,
|
| - Identifier identifier)
|
| - : this.identifier = identifier,
|
| - super(identifier.source, elementKind, enclosingElement);
|
| -
|
| - FunctionTypedElement get functionDeclaration => enclosingElement;
|
| -
|
| - Modifiers get modifiers => definitions.modifiers;
|
| -
|
| - Token get position => identifier.getBeginToken();
|
| -
|
| - Node parseNode(DiagnosticListener listener) => definitions;
|
| -
|
| - DartType computeType(Compiler compiler) {
|
| - assert(invariant(this, type != null,
|
| - message: "Parameter type has not been set for $this."));
|
| - return type;
|
| - }
|
| -
|
| - DartType get type {
|
| - assert(invariant(this, typeCache != null,
|
| - message: "Parameter type has not been set for $this."));
|
| - return typeCache;
|
| - }
|
| -
|
| - FunctionSignature get functionSignature {
|
| - assert(invariant(this, typeCache != null,
|
| - message: "Parameter signature has not been set for $this."));
|
| - return functionSignatureCache;
|
| - }
|
| -
|
| - bool get hasNode => true;
|
| -
|
| - VariableDefinitions get node => definitions;
|
| -
|
| - FunctionType get functionType => type;
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitFormalElement(this);
|
| -
|
| - // A parameter is defined by the declaration element.
|
| - AstElement get definingElement => declaration;
|
| -}
|
| -
|
| -/// [Element] for a formal parameter.
|
| -///
|
| -/// A [ParameterElementX] can be patched. A parameter of an external method is
|
| -/// patched with the corresponding parameter of the patch method. This is done
|
| -/// to ensure that default values on parameters are computed once (on the
|
| -/// origin parameter) but can be found through both the origin and the patch.
|
| -abstract class ParameterElementX extends FormalElementX
|
| - with PatchMixin<ParameterElement> implements ParameterElement {
|
| - final Expression initializer;
|
| -
|
| - ParameterElementX(ElementKind elementKind,
|
| - FunctionElement functionDeclaration,
|
| - VariableDefinitions definitions,
|
| - Identifier identifier,
|
| - this.initializer)
|
| - : super(elementKind, functionDeclaration, definitions, identifier);
|
| -
|
| - FunctionElement get functionDeclaration => enclosingElement;
|
| -
|
| - ExecutableElement get executableContext => enclosingElement;
|
| -
|
| - MemberElement get memberContext => executableContext.memberContext;
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
|
| -
|
| - bool get isLocal => true;
|
| -}
|
| -
|
| -class LocalParameterElementX extends ParameterElementX
|
| - implements LocalParameterElement {
|
| - LocalParameterElementX(FunctionElement functionDeclaration,
|
| - VariableDefinitions definitions,
|
| - Identifier identifier,
|
| - Expression initializer)
|
| - : super(ElementKind.PARAMETER, functionDeclaration,
|
| - definitions, identifier, initializer);
|
| -}
|
| -
|
| -/// Parameters in constructors that directly initialize fields. For example:
|
| -/// `A(this.field)`.
|
| -class InitializingFormalElementX extends ParameterElementX
|
| - implements InitializingFormalElement {
|
| - FieldElement fieldElement;
|
| -
|
| - InitializingFormalElementX(ConstructorElement constructorDeclaration,
|
| - VariableDefinitions variables,
|
| - Identifier identifier,
|
| - Expression initializer,
|
| - this.fieldElement)
|
| - : super(ElementKind.INITIALIZING_FORMAL, constructorDeclaration,
|
| - variables, identifier, initializer);
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitFieldParameterElement(this);
|
| -
|
| - MemberElement get memberContext => enclosingElement;
|
| -
|
| - bool get isLocal => false;
|
| -}
|
| -
|
| -
|
| -class AbstractFieldElementX extends ElementX implements AbstractFieldElement {
|
| - FunctionElementX getter;
|
| - FunctionElementX setter;
|
| -
|
| - AbstractFieldElementX(String name, Element enclosing)
|
| - : super(name, ElementKind.ABSTRACT_FIELD, enclosing);
|
| -
|
| - DartType computeType(Compiler compiler) {
|
| - throw "internal error: AbstractFieldElement has no type";
|
| - }
|
| -
|
| - Node parseNode(DiagnosticListener listener) {
|
| - throw "internal error: AbstractFieldElement has no node";
|
| - }
|
| -
|
| - Token get position {
|
| - // The getter and setter may be defined in two different
|
| - // compilation units. However, we know that one of them is
|
| - // non-null and defined in the same compilation unit as the
|
| - // abstract element.
|
| - // TODO(lrn): No we don't know that if the element from the same
|
| - // compilation unit is patched.
|
| - //
|
| - // We need to make sure that the position returned is relative to
|
| - // the compilation unit of the abstract element.
|
| - if (getter != null
|
| - && identical(getter.compilationUnit, compilationUnit)) {
|
| - return getter.position;
|
| - } else {
|
| - return setter.position;
|
| - }
|
| - }
|
| -
|
| - Modifiers get modifiers {
|
| - // The resolver ensures that the flags match (ignoring abstract).
|
| - if (getter != null) {
|
| - return new Modifiers.withFlags(
|
| - getter.modifiers.nodes,
|
| - getter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
|
| - } else {
|
| - return new Modifiers.withFlags(
|
| - setter.modifiers.nodes,
|
| - setter.modifiers.flags | Modifiers.FLAG_ABSTRACT);
|
| - }
|
| - }
|
| -
|
| - bool get isInstanceMember {
|
| - return isClassMember && !isStatic;
|
| - }
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitAbstractFieldElement(this);
|
| -
|
| - bool get isAbstract {
|
| - return getter != null && getter.isAbstract
|
| - || setter != null && setter.isAbstract;
|
| - }
|
| -}
|
| -
|
| -// TODO(johnniwinther): [FunctionSignature] should be merged with
|
| -// [FunctionType].
|
| -// TODO(karlklose): all these lists should have element type [FormalElement].
|
| -class FunctionSignatureX implements FunctionSignature {
|
| - final Link<Element> requiredParameters;
|
| - final Link<Element> optionalParameters;
|
| - final int requiredParameterCount;
|
| - final int optionalParameterCount;
|
| - final bool optionalParametersAreNamed;
|
| - final List<Element> orderedOptionalParameters;
|
| - final FunctionType type;
|
| - final bool hasOptionalParameters;
|
| -
|
| - FunctionSignatureX(this.requiredParameters,
|
| - Link<Element> optionalParameters,
|
| - this.requiredParameterCount,
|
| - this.optionalParameterCount,
|
| - this.optionalParametersAreNamed,
|
| - this.orderedOptionalParameters,
|
| - this.type)
|
| - : optionalParameters = optionalParameters,
|
| - hasOptionalParameters = !optionalParameters.isEmpty;
|
| -
|
| - void forEachRequiredParameter(void function(Element parameter)) {
|
| - for (Link<Element> link = requiredParameters;
|
| - !link.isEmpty;
|
| - link = link.tail) {
|
| - function(link.head);
|
| - }
|
| - }
|
| -
|
| - void forEachOptionalParameter(void function(Element parameter)) {
|
| - for (Link<Element> link = optionalParameters;
|
| - !link.isEmpty;
|
| - link = link.tail) {
|
| - function(link.head);
|
| - }
|
| - }
|
| -
|
| - Element get firstOptionalParameter => optionalParameters.head;
|
| -
|
| - void forEachParameter(void function(Element parameter)) {
|
| - forEachRequiredParameter(function);
|
| - forEachOptionalParameter(function);
|
| - }
|
| -
|
| - void orderedForEachParameter(void function(Element parameter)) {
|
| - forEachRequiredParameter(function);
|
| - orderedOptionalParameters.forEach(function);
|
| - }
|
| -
|
| - int get parameterCount => requiredParameterCount + optionalParameterCount;
|
| -
|
| - /**
|
| - * Check whether a function with this signature can be used instead of a
|
| - * function with signature [signature] without causing a `noSuchMethod`
|
| - * exception/call.
|
| - */
|
| - bool isCompatibleWith(FunctionSignature signature) {
|
| - if (optionalParametersAreNamed) {
|
| - if (!signature.optionalParametersAreNamed) {
|
| - return requiredParameterCount == signature.parameterCount;
|
| - }
|
| - // If both signatures have named parameters, then they must have
|
| - // the same number of required parameters, and the names in
|
| - // [signature] must all be in [:this:].
|
| - if (requiredParameterCount != signature.requiredParameterCount) {
|
| - return false;
|
| - }
|
| - Set<String> names = optionalParameters.mapToSet(
|
| - (Element element) => element.name);
|
| - for (Element namedParameter in signature.optionalParameters) {
|
| - if (!names.contains(namedParameter.name)) {
|
| - return false;
|
| - }
|
| - }
|
| - } else {
|
| - if (signature.optionalParametersAreNamed) return false;
|
| - // There must be at least as many arguments as in the other signature, but
|
| - // this signature must not have more required parameters. Having more
|
| - // optional parameters is not a problem, they simply are never provided
|
| - // by call sites of a call to a method with the other signature.
|
| - int otherTotalCount = signature.parameterCount;
|
| - return requiredParameterCount <= otherTotalCount
|
| - && parameterCount >= otherTotalCount;
|
| - }
|
| - return true;
|
| - }
|
| -}
|
| -
|
| -abstract class BaseFunctionElementX
|
| - extends ElementX with PatchMixin<FunctionElement>, AstElementMixin
|
| - implements FunctionElement {
|
| - DartType typeCache;
|
| - final Modifiers modifiers;
|
| -
|
| - List<FunctionElement> nestedClosures = new List<FunctionElement>();
|
| -
|
| - FunctionSignature functionSignatureCache;
|
| -
|
| - final bool _hasNoBody;
|
| -
|
| - AbstractFieldElement abstractField;
|
| -
|
| - AsyncMarker asyncMarker = AsyncMarker.SYNC;
|
| -
|
| - BaseFunctionElementX(String name,
|
| - ElementKind kind,
|
| - Modifiers this.modifiers,
|
| - Element enclosing,
|
| - bool hasNoBody)
|
| - : super(name, kind, enclosing),
|
| - _hasNoBody = hasNoBody {
|
| - assert(modifiers != null);
|
| - }
|
| -
|
| - bool get isInstanceMember {
|
| - return isClassMember
|
| - && !isConstructor
|
| - && !isStatic;
|
| - }
|
| -
|
| - bool get hasFunctionSignature => functionSignatureCache != null;
|
| -
|
| - FunctionSignature computeSignature(Compiler compiler) {
|
| - if (functionSignatureCache != null) return functionSignatureCache;
|
| - compiler.withCurrentElement(this, () {
|
| - functionSignatureCache = compiler.resolver.resolveSignature(this);
|
| - });
|
| - return functionSignatureCache;
|
| - }
|
| -
|
| - FunctionSignature get functionSignature {
|
| - assert(invariant(this, functionSignatureCache != null,
|
| - message: "Function signature has not been computed for $this."));
|
| - return functionSignatureCache;
|
| - }
|
| -
|
| - FunctionType computeType(Compiler compiler) {
|
| - if (typeCache != null) return typeCache;
|
| - typeCache = computeSignature(compiler).type;
|
| - return typeCache;
|
| - }
|
| -
|
| - FunctionType get type {
|
| - assert(invariant(this, typeCache != null,
|
| - message: "Type has not been computed for $this."));
|
| - return typeCache;
|
| - }
|
| -
|
| - FunctionElement asFunctionElement() => this;
|
| -
|
| - String toString() {
|
| - if (isPatch) {
|
| - return 'patch ${super.toString()}';
|
| - } else if (isPatched) {
|
| - return 'origin ${super.toString()}';
|
| - } else {
|
| - return super.toString();
|
| - }
|
| - }
|
| -
|
| - bool get isAbstract {
|
| - return !modifiers.isExternal &&
|
| - (isFunction || isAccessor) &&
|
| - _hasNoBody;
|
| - }
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
|
| -
|
| - // A function is defined by the implementation element.
|
| - AstElement get definingElement => implementation;
|
| -}
|
| -
|
| -abstract class FunctionElementX extends BaseFunctionElementX
|
| - with AnalyzableElementX implements MemberElement {
|
| - FunctionElementX(String name,
|
| - ElementKind kind,
|
| - Modifiers modifiers,
|
| - Element enclosing,
|
| - bool hasNoBody)
|
| - : super(name, kind, modifiers, enclosing, hasNoBody);
|
| -
|
| - MemberElement get memberContext => this;
|
| -
|
| - void reuseElement() {
|
| - super.reuseElement();
|
| - nestedClosures.clear();
|
| - functionSignatureCache = null;
|
| - typeCache = null;
|
| - }
|
| -}
|
| -
|
| -class LocalFunctionElementX extends BaseFunctionElementX
|
| - implements LocalFunctionElement {
|
| - final FunctionExpression node;
|
| -
|
| - LocalFunctionElementX(String name,
|
| - FunctionExpression this.node,
|
| - ElementKind kind,
|
| - Modifiers modifiers,
|
| - ExecutableElement enclosing)
|
| - : super(name, kind, modifiers, enclosing, false);
|
| -
|
| - ExecutableElement get executableContext => enclosingElement;
|
| -
|
| - MemberElement get memberContext => executableContext.memberContext;
|
| -
|
| - bool get hasNode => true;
|
| -
|
| - FunctionExpression parseNode(DiagnosticListener listener) => node;
|
| -
|
| - Token get position {
|
| - // Use the name as position if this is not an unnamed closure.
|
| - if (node.name != null) {
|
| - return node.name.getBeginToken();
|
| - } else {
|
| - return node.getBeginToken();
|
| - }
|
| - }
|
| -
|
| - bool get isLocal => true;
|
| -}
|
| -
|
| -abstract class ConstructorElementX extends FunctionElementX
|
| - implements ConstructorElement {
|
| -
|
| - ConstructorElementX(String name,
|
| - ElementKind kind,
|
| - Modifiers modifiers,
|
| - Element enclosing)
|
| - : super(name, kind, modifiers, enclosing, false);
|
| -
|
| - FunctionElement immediateRedirectionTarget;
|
| -
|
| - bool get isRedirectingFactory => immediateRedirectionTarget != null;
|
| -
|
| - /// This field is set by the post process queue when checking for cycles.
|
| - ConstructorElement internalEffectiveTarget;
|
| - DartType effectiveTargetType;
|
| -
|
| - void set effectiveTarget(ConstructorElement constructor) {
|
| - assert(constructor != null && internalEffectiveTarget == null);
|
| - internalEffectiveTarget = constructor;
|
| - }
|
| -
|
| - ConstructorElement get effectiveTarget {
|
| - if (Elements.isErroneousElement(immediateRedirectionTarget)) {
|
| - return immediateRedirectionTarget;
|
| - }
|
| - assert(!isRedirectingFactory || internalEffectiveTarget != null);
|
| - return isRedirectingFactory ? internalEffectiveTarget : this;
|
| - }
|
| -
|
| - InterfaceType computeEffectiveTargetType(InterfaceType newType) {
|
| - if (!isRedirectingFactory) return newType;
|
| - assert(invariant(this, effectiveTargetType != null,
|
| - message: 'Redirection target type has not yet been computed for '
|
| - '$this.'));
|
| - return effectiveTargetType.substByContext(newType);
|
| - }
|
| -
|
| - ConstructorElement get definingConstructor => null;
|
| -
|
| - ClassElement get enclosingClass => enclosingElement;
|
| -}
|
| -
|
| -class DeferredLoaderGetterElementX extends FunctionElementX {
|
| - final PrefixElement prefix;
|
| -
|
| - DeferredLoaderGetterElementX(PrefixElement prefix)
|
| - : this.prefix = prefix,
|
| - super("loadLibrary",
|
| - ElementKind.FUNCTION,
|
| - Modifiers.EMPTY,
|
| - prefix, true);
|
| -
|
| - FunctionSignature computeSignature(Compiler compiler) {
|
| - if (functionSignatureCache != null) return functionSignature;
|
| - compiler.withCurrentElement(this, () {
|
| - DartType inner = new FunctionType(this);
|
| - functionSignatureCache = new FunctionSignatureX(const Link(),
|
| - const Link(), 0, 0, false, [], inner);
|
| - });
|
| - return functionSignatureCache;
|
| - }
|
| -
|
| - bool get isClassMember => false;
|
| -
|
| - bool isForeign(Backend backend) => true;
|
| -
|
| - bool get isSynthesized => true;
|
| -
|
| - bool get isFunction => false;
|
| -
|
| - bool get isDeferredLoaderGetter => true;
|
| -
|
| - bool get isGetter => true;
|
| -
|
| - bool get isTopLevel => true;
|
| - // By having position null, the enclosing elements location is printed in
|
| - // error messages.
|
| - Token get position => null;
|
| -
|
| - FunctionExpression parseNode(DiagnosticListener listener) => null;
|
| -
|
| - bool get hasNode => false;
|
| -
|
| - FunctionExpression get node => null;
|
| -}
|
| -
|
| -class ConstructorBodyElementX extends BaseFunctionElementX
|
| - implements ConstructorBodyElement {
|
| - ConstructorElement constructor;
|
| -
|
| - ConstructorBodyElementX(FunctionElement constructor)
|
| - : this.constructor = constructor,
|
| - super(constructor.name,
|
| - ElementKind.GENERATIVE_CONSTRUCTOR_BODY,
|
| - Modifiers.EMPTY,
|
| - constructor.enclosingElement, false) {
|
| - functionSignatureCache = constructor.functionSignature;
|
| - }
|
| -
|
| - bool get hasNode => constructor.hasNode;
|
| -
|
| - FunctionExpression get node => constructor.node;
|
| -
|
| - bool get isInstanceMember => true;
|
| -
|
| - FunctionType computeType(Compiler compiler) {
|
| - compiler.internalError(this, '$this.computeType.');
|
| - return null;
|
| - }
|
| -
|
| - Token get position => constructor.position;
|
| -
|
| - Element get outermostEnclosingMemberOrTopLevel => constructor;
|
| -
|
| - Element get analyzableElement => constructor.analyzableElement;
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitConstructorBodyElement(this);
|
| -
|
| - MemberElement get memberContext => constructor;
|
| -}
|
| -
|
| -/**
|
| - * A constructor that is not defined in the source code but rather implied by
|
| - * the language semantics.
|
| - *
|
| - * This class is used to represent default constructors and forwarding
|
| - * constructors for mixin applications.
|
| - */
|
| -class SynthesizedConstructorElementX extends ConstructorElementX {
|
| - final ConstructorElement definingConstructor;
|
| - final bool isDefaultConstructor;
|
| -
|
| - SynthesizedConstructorElementX(String name,
|
| - this.definingConstructor,
|
| - Element enclosing,
|
| - this.isDefaultConstructor)
|
| - : super(name,
|
| - ElementKind.GENERATIVE_CONSTRUCTOR,
|
| - Modifiers.EMPTY,
|
| - enclosing);
|
| -
|
| - SynthesizedConstructorElementX.forDefault(superMember, Element enclosing)
|
| - : this('', superMember, enclosing, true);
|
| -
|
| - FunctionExpression parseNode(DiagnosticListener listener) => null;
|
| -
|
| - bool get hasNode => false;
|
| -
|
| - FunctionExpression get node => null;
|
| -
|
| - Token get position => enclosingElement.position;
|
| -
|
| - bool get isSynthesized => true;
|
| -
|
| - FunctionSignature computeSignature(compiler) {
|
| - if (functionSignatureCache != null) return functionSignatureCache;
|
| - if (isDefaultConstructor) {
|
| - return functionSignatureCache = new FunctionSignatureX(
|
| - const Link<Element>(), const Link<Element>(), 0, 0, false,
|
| - const <Element>[],
|
| - new FunctionType(this, enclosingClass.thisType));
|
| - }
|
| - if (definingConstructor.isErroneous) {
|
| - return functionSignatureCache =
|
| - compiler.objectClass.localLookup('').computeSignature(compiler);
|
| - }
|
| - // TODO(johnniwinther): Ensure that the function signature (and with it the
|
| - // function type) substitutes type variables correctly.
|
| - return functionSignatureCache =
|
| - definingConstructor.computeSignature(compiler);
|
| - }
|
| -
|
| - accept(ElementVisitor visitor) {
|
| - return visitor.visitFunctionElement(this);
|
| - }
|
| -}
|
| -
|
| -abstract class TypeDeclarationElementX<T extends GenericType>
|
| - implements TypeDeclarationElement {
|
| - /**
|
| - * The `this type` for this type declaration.
|
| - *
|
| - * The type of [:this:] is the generic type based on this element in which
|
| - * the type arguments are the declared type variables. For instance,
|
| - * [:List<E>:] for [:List:] and [:Map<K,V>:] for [:Map:].
|
| - *
|
| - * For a class declaration this is the type of [:this:].
|
| - *
|
| - * This type is computed in [computeType].
|
| - */
|
| - T thisTypeCache;
|
| -
|
| - /**
|
| - * The raw type for this type declaration.
|
| - *
|
| - * The raw type is the generic type base on this element in which the type
|
| - * arguments are all [dynamic]. For instance [:List<dynamic>:] for [:List:]
|
| - * and [:Map<dynamic,dynamic>:] for [:Map:]. For non-generic classes [rawType]
|
| - * is the same as [thisType].
|
| - *
|
| - * The [rawType] field is a canonicalization of the raw type and should be
|
| - * used to distinguish explicit and implicit uses of the [dynamic]
|
| - * type arguments. For instance should [:List:] be the [rawType] of the
|
| - * [:List:] class element whereas [:List<dynamic>:] should be its own
|
| - * instantiation of [InterfaceType] with [:dynamic:] as type argument. Using
|
| - * this distinction, we can print the raw type with type arguments only when
|
| - * the input source has used explicit type arguments.
|
| - *
|
| - * This type is computed together with [thisType] in [computeType].
|
| - */
|
| - T rawTypeCache;
|
| -
|
| - T get thisType {
|
| - assert(invariant(this, thisTypeCache != null,
|
| - message: 'This type has not been computed for $this'));
|
| - return thisTypeCache;
|
| - }
|
| -
|
| - T get rawType {
|
| - assert(invariant(this, rawTypeCache != null,
|
| - message: 'Raw type has not been computed for $this'));
|
| - return rawTypeCache;
|
| - }
|
| -
|
| - T createType(List<DartType> typeArguments);
|
| -
|
| - void setThisAndRawTypes(Compiler compiler, List<DartType> typeParameters) {
|
| - assert(invariant(this, thisTypeCache == null,
|
| - message: "This type has already been set on $this."));
|
| - assert(invariant(this, rawTypeCache == null,
|
| - message: "Raw type has already been set on $this."));
|
| - thisTypeCache = createType(typeParameters);
|
| - if (typeParameters.isEmpty) {
|
| - rawTypeCache = thisTypeCache;
|
| - } else {
|
| - List<DartType> dynamicParameters =
|
| - new List.filled(typeParameters.length, const DynamicType());
|
| - rawTypeCache = createType(dynamicParameters);
|
| - }
|
| - }
|
| -
|
| - List<DartType> get typeVariables => thisType.typeArguments;
|
| -
|
| - /**
|
| - * Creates the type variables, their type and corresponding element, for the
|
| - * type variables declared in [parameter] on [element]. The bounds of the type
|
| - * variables are not set until [element] has been resolved.
|
| - */
|
| - List<DartType> createTypeVariables(NodeList parameters) {
|
| - if (parameters == null) return const <DartType>[];
|
| -
|
| - // Create types and elements for type variable.
|
| - Link<Node> nodes = parameters.nodes;
|
| - List<DartType> arguments =
|
| - new List.generate(nodes.slowLength(), (_) {
|
| - TypeVariable node = nodes.head;
|
| - String variableName = node.name.source;
|
| - nodes = nodes.tail;
|
| - TypeVariableElementX variableElement =
|
| - new TypeVariableElementX(variableName, this, node);
|
| - TypeVariableType variableType = new TypeVariableType(variableElement);
|
| - variableElement.typeCache = variableType;
|
| - return variableType;
|
| - }, growable: false);
|
| - return arguments;
|
| - }
|
| -
|
| - bool get isResolved => resolutionState == STATE_DONE;
|
| -}
|
| -
|
| -abstract class BaseClassElementX extends ElementX
|
| - with AstElementMixin,
|
| - AnalyzableElementX,
|
| - TypeDeclarationElementX<InterfaceType>,
|
| - PatchMixin<ClassElement>,
|
| - ClassMemberMixin
|
| - implements ClassElement {
|
| - final int id;
|
| -
|
| - DartType supertype;
|
| - Link<DartType> interfaces;
|
| - String nativeTagInfo;
|
| - int supertypeLoadState;
|
| - int resolutionState;
|
| - bool isProxy = false;
|
| - bool hasIncompleteHierarchy = false;
|
| -
|
| - // backendMembers are members that have been added by the backend to simplify
|
| - // compilation. They don't have any user-side counter-part.
|
| - Link<Element> backendMembers = const Link<Element>();
|
| -
|
| - OrderedTypeSet allSupertypesAndSelf;
|
| -
|
| - Link<DartType> get allSupertypes => allSupertypesAndSelf.supertypes;
|
| -
|
| - int get hierarchyDepth => allSupertypesAndSelf.maxDepth;
|
| -
|
| - BaseClassElementX(String name,
|
| - Element enclosing,
|
| - this.id,
|
| - int initialState)
|
| - : supertypeLoadState = initialState,
|
| - resolutionState = initialState,
|
| - super(name, ElementKind.CLASS, enclosing);
|
| -
|
| - int get hashCode => id;
|
| -
|
| - bool get hasBackendMembers => !backendMembers.isEmpty;
|
| -
|
| - bool get isUnnamedMixinApplication => false;
|
| -
|
| - InterfaceType computeType(Compiler compiler) {
|
| - if (thisTypeCache == null) {
|
| - computeThisAndRawType(compiler, computeTypeParameters(compiler));
|
| - }
|
| - return thisTypeCache;
|
| - }
|
| -
|
| - void computeThisAndRawType(Compiler compiler, List<DartType> typeVariables) {
|
| - if (thisTypeCache == null) {
|
| - if (origin == null) {
|
| - setThisAndRawTypes(compiler, typeVariables);
|
| - } else {
|
| - thisTypeCache = origin.computeType(compiler);
|
| - rawTypeCache = origin.rawType;
|
| - }
|
| - }
|
| - }
|
| -
|
| - InterfaceType createType(List<DartType> typeArguments) {
|
| - return new InterfaceType(this, typeArguments);
|
| - }
|
| -
|
| - List<DartType> computeTypeParameters(Compiler compiler);
|
| -
|
| - InterfaceType asInstanceOf(ClassElement cls) {
|
| - if (cls == this) return thisType;
|
| - return allSupertypesAndSelf.asInstanceOf(cls);
|
| - }
|
| -
|
| - bool get isObject {
|
| - assert(invariant(this, isResolved,
|
| - message: "isObject has not been computed for $this."));
|
| - return supertype == null;
|
| - }
|
| -
|
| - void ensureResolved(Compiler compiler) {
|
| - if (resolutionState == STATE_NOT_STARTED) {
|
| - compiler.resolver.resolveClass(this);
|
| - }
|
| - }
|
| -
|
| - void setDefaultConstructor(FunctionElement constructor, Compiler compiler);
|
| -
|
| - void addBackendMember(Element member) {
|
| - // TODO(ngeoffray): Deprecate this method.
|
| - assert(member.isGenerativeConstructorBody);
|
| - backendMembers = backendMembers.prepend(member);
|
| - }
|
| -
|
| - void reverseBackendMembers() {
|
| - backendMembers = backendMembers.reverse();
|
| - }
|
| -
|
| - /**
|
| - * Lookup local members in the class. This will ignore constructors.
|
| - */
|
| - Element lookupLocalMember(String memberName) {
|
| - var result = localLookup(memberName);
|
| - if (result != null && result.isConstructor) return null;
|
| - return result;
|
| - }
|
| -
|
| - /// Lookup a synthetic element created by the backend.
|
| - Element lookupBackendMember(String memberName) {
|
| - for (Element element in backendMembers) {
|
| - if (element.name == memberName) {
|
| - return element;
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| - /**
|
| - * Lookup super members for the class. This will ignore constructors.
|
| - */
|
| - Element lookupSuperMember(String memberName) {
|
| - return lookupSuperMemberInLibrary(memberName, library);
|
| - }
|
| -
|
| - /**
|
| - * Lookup super members for the class that is accessible in [library].
|
| - * This will ignore constructors.
|
| - */
|
| - Element lookupSuperMemberInLibrary(String memberName,
|
| - LibraryElement library) {
|
| - bool isPrivate = isPrivateName(memberName);
|
| - for (ClassElement s = superclass; s != null; s = s.superclass) {
|
| - // Private members from a different library are not visible.
|
| - if (isPrivate && !identical(library, s.library)) continue;
|
| - Element e = s.lookupLocalMember(memberName);
|
| - if (e == null) continue;
|
| - // Static members are not inherited.
|
| - if (e.isStatic) continue;
|
| - return e;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Find the first member in the class chain with the given [selector].
|
| - *
|
| - * This method is NOT to be used for resolving
|
| - * unqualified sends because it does not implement the scoping
|
| - * rules, where library scope comes before superclass scope.
|
| - *
|
| - * When called on the implementation element both members declared in the
|
| - * origin and the patch class are returned.
|
| - */
|
| - Element lookupSelector(Selector selector) {
|
| - return internalLookupSelector(selector, false);
|
| - }
|
| -
|
| - Element lookupSuperSelector(Selector selector) {
|
| - return internalLookupSelector(selector, true);
|
| - }
|
| -
|
| - Element internalLookupSelector(Selector selector,
|
| - bool isSuperLookup) {
|
| - String name = selector.name;
|
| - bool isPrivate = isPrivateName(name);
|
| - LibraryElement library = selector.library;
|
| - for (ClassElement current = isSuperLookup ? superclass : this;
|
| - current != null;
|
| - current = current.superclass) {
|
| - Element member = current.lookupLocalMember(name);
|
| - if (member == null && current.isPatched) {
|
| - // Doing lookups on selectors is done after resolution, so it
|
| - // is safe to look in the patch class.
|
| - member = current.patch.lookupLocalMember(name);
|
| - }
|
| - if (member == null) continue;
|
| - // Private members from a different library are not visible.
|
| - if (isPrivate && !identical(library, member.library)) continue;
|
| - // Static members are not inherited.
|
| - if (member.isStatic && !identical(this, current)) continue;
|
| - // If we find an abstract field we have to make sure that it has
|
| - // the getter or setter part we're actually looking
|
| - // for. Otherwise, we continue up the superclass chain.
|
| - if (member.isAbstractField) {
|
| - AbstractFieldElement field = member;
|
| - FunctionElement getter = field.getter;
|
| - FunctionElement setter = field.setter;
|
| - if (selector.isSetter) {
|
| - // Abstract members can be defined in a super class.
|
| - if (setter != null && !setter.isAbstract) return setter;
|
| - } else {
|
| - assert(selector.isGetter || selector.isCall);
|
| - if (getter != null && !getter.isAbstract) return getter;
|
| - }
|
| - // Abstract members can be defined in a super class.
|
| - } else if (!member.isAbstract) {
|
| - return member;
|
| - }
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - /**
|
| - * Find the first member in the class chain with the given
|
| - * [memberName]. This method is NOT to be used for resolving
|
| - * unqualified sends because it does not implement the scoping
|
| - * rules, where library scope comes before superclass scope.
|
| - */
|
| - Element lookupMember(String memberName) {
|
| - Element localMember = lookupLocalMember(memberName);
|
| - return localMember == null ? lookupSuperMember(memberName) : localMember;
|
| - }
|
| -
|
| - /**
|
| - * Returns true if the [fieldMember] shadows another field. The given
|
| - * [fieldMember] must be a member of this class, i.e. if there is a field of
|
| - * the same name in the superclass chain.
|
| - *
|
| - * This method also works if the [fieldMember] is private.
|
| - */
|
| - bool hasFieldShadowedBy(Element fieldMember) {
|
| - assert(fieldMember.isField);
|
| - String fieldName = fieldMember.name;
|
| - bool isPrivate = isPrivateName(fieldName);
|
| - LibraryElement memberLibrary = fieldMember.library;
|
| - ClassElement lookupClass = this.superclass;
|
| - while (lookupClass != null) {
|
| - Element foundMember = lookupClass.lookupLocalMember(fieldName);
|
| - if (foundMember != null) {
|
| - if (foundMember.isField) {
|
| - if (!isPrivate || memberLibrary == foundMember.library) {
|
| - // Private fields can only be shadowed by a field declared in the
|
| - // same library.
|
| - return true;
|
| - }
|
| - }
|
| - }
|
| - lookupClass = lookupClass.superclass;
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - Element validateConstructorLookupResults(Selector selector,
|
| - Element result,
|
| - Element noMatch(Element)) {
|
| - if (result == null
|
| - || !result.isConstructor
|
| - || (isPrivateName(selector.name)
|
| - && result.library != selector.library)) {
|
| - result = noMatch != null ? noMatch(result) : null;
|
| - }
|
| - return result;
|
| - }
|
| -
|
| - // TODO(aprelev@gmail.com): Peter believes that it would be great to
|
| - // make noMatch a required argument. Peter's suspicion is that most
|
| - // callers of this method would benefit from using the noMatch method.
|
| - Element lookupConstructor(Selector selector, [Element noMatch(Element)]) {
|
| - Element result = localLookup(selector.name);
|
| - return validateConstructorLookupResults(selector, result, noMatch);
|
| - }
|
| -
|
| - Link<Element> get constructors {
|
| - // TODO(ajohnsen): See if we can avoid this method at some point.
|
| - Link<Element> result = const Link<Element>();
|
| - // TODO(johnniwinther): Should we include injected constructors?
|
| - forEachMember((_, Element member) {
|
| - if (member.isConstructor) result = result.prepend(member);
|
| - });
|
| - return result;
|
| - }
|
| -
|
| - /**
|
| - * Returns the super class, if any.
|
| - *
|
| - * The returned element may not be resolved yet.
|
| - */
|
| - ClassElement get superclass {
|
| - assert(supertypeLoadState == STATE_DONE);
|
| - return supertype == null ? null : supertype.element;
|
| - }
|
| -
|
| - /**
|
| - * Runs through all members of this class.
|
| - *
|
| - * The enclosing class is passed to the callback. This is useful when
|
| - * [includeSuperAndInjectedMembers] is [:true:].
|
| - *
|
| - * When called on an implementation element both the members in the origin
|
| - * and patch class are included.
|
| - */
|
| - // TODO(johnniwinther): Clean up lookup to get rid of the include predicates.
|
| - void forEachMember(void f(ClassElement enclosingClass, Element member),
|
| - {includeBackendMembers: false,
|
| - includeSuperAndInjectedMembers: false}) {
|
| - bool includeInjectedMembers = includeSuperAndInjectedMembers || isPatch;
|
| - ClassElement classElement = declaration;
|
| - do {
|
| - // Iterate through the members in textual order, which requires
|
| - // to reverse the data structure [localMembers] we created.
|
| - // Textual order may be important for certain operations, for
|
| - // example when emitting the initializers of fields.
|
| - classElement.forEachLocalMember((e) => f(classElement, e));
|
| - if (includeBackendMembers) {
|
| - classElement.forEachBackendMember((e) => f(classElement, e));
|
| - }
|
| - if (includeInjectedMembers) {
|
| - if (classElement.patch != null) {
|
| - classElement.patch.forEachLocalMember((e) {
|
| - if (!e.isPatch) f(classElement, e);
|
| - });
|
| - }
|
| - }
|
| - classElement = includeSuperAndInjectedMembers
|
| - ? classElement.superclass
|
| - : null;
|
| - } while (classElement != null);
|
| - }
|
| -
|
| - /**
|
| - * Runs through all instance-field members of this class.
|
| - *
|
| - * The enclosing class is passed to the callback. This is useful when
|
| - * [includeSuperAndInjectedMembers] is [:true:].
|
| - *
|
| - * When called on the implementation element both the fields declared in the
|
| - * origin and in the patch are included.
|
| - */
|
| - void forEachInstanceField(void f(ClassElement enclosingClass,
|
| - FieldElement field),
|
| - {bool includeSuperAndInjectedMembers: false}) {
|
| - // Filters so that [f] is only invoked with instance fields.
|
| - void fieldFilter(ClassElement enclosingClass, Element member) {
|
| - if (member.isInstanceMember && member.kind == ElementKind.FIELD) {
|
| - f(enclosingClass, member);
|
| - }
|
| - }
|
| -
|
| - forEachMember(fieldFilter,
|
| - includeSuperAndInjectedMembers: includeSuperAndInjectedMembers);
|
| - }
|
| -
|
| - /// Similar to [forEachInstanceField] but visits static fields.
|
| - void forEachStaticField(void f(ClassElement enclosingClass, Element field)) {
|
| - // Filters so that [f] is only invoked with static fields.
|
| - void fieldFilter(ClassElement enclosingClass, Element member) {
|
| - if (!member.isInstanceMember && member.kind == ElementKind.FIELD) {
|
| - f(enclosingClass, member);
|
| - }
|
| - }
|
| -
|
| - forEachMember(fieldFilter);
|
| - }
|
| -
|
| - void forEachBackendMember(void f(Element member)) {
|
| - backendMembers.forEach(f);
|
| - }
|
| -
|
| - bool implementsInterface(ClassElement intrface) {
|
| - for (DartType implementedInterfaceType in allSupertypes) {
|
| - ClassElement implementedInterface = implementedInterfaceType.element;
|
| - if (identical(implementedInterface, intrface)) {
|
| - return true;
|
| - }
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - /**
|
| - * Returns true if [this] is a subclass of [cls].
|
| - *
|
| - * This method is not to be used for checking type hierarchy and
|
| - * assignments, because it does not take parameterized types into
|
| - * account.
|
| - */
|
| - bool isSubclassOf(ClassElement cls) {
|
| - // Use [declaration] for both [this] and [cls], because
|
| - // declaration classes hold the superclass hierarchy.
|
| - cls = cls.declaration;
|
| - for (ClassElement s = declaration; s != null; s = s.superclass) {
|
| - if (identical(s, cls)) return true;
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - bool get isNative => nativeTagInfo != null;
|
| -
|
| - void setNative(String name) {
|
| - // TODO(johnniwinther): Assert that this is only called once. The memory
|
| - // compiler copies pre-processed elements into a new compiler through
|
| - // [Compiler.onLibraryScanned] and thereby causes multiple calls to this
|
| - // method.
|
| - assert(invariant(this, nativeTagInfo == null || nativeTagInfo == name,
|
| - message: "Native tag info set inconsistently on $this: "
|
| - "Existing name '$nativeTagInfo', new name '$name'."));
|
| - nativeTagInfo = name;
|
| - }
|
| -
|
| - FunctionType get callType {
|
| - MemberSignature member =
|
| - lookupInterfaceMember(const PublicName(Compiler.CALL_OPERATOR_NAME));
|
| - return member != null && member.isMethod ? member.type : null;
|
| - }
|
| -
|
| - // TODO(johnniwinther): Remove these when issue 18630 is fixed.
|
| - ClassElement get patch => super.patch;
|
| - ClassElement get origin => super.origin;
|
| -
|
| - // A class declaration is defined by the declaration element.
|
| - AstElement get definingElement => declaration;
|
| -}
|
| -
|
| -abstract class ClassElementX extends BaseClassElementX {
|
| - Link<Element> localMembersReversed = const Link<Element>();
|
| - final ScopeX localScope = new ScopeX();
|
| -
|
| - Link<Element> localMembersCache;
|
| -
|
| - Link<Element> get localMembers {
|
| - if (localMembersCache == null) {
|
| - localMembersCache = localMembersReversed.reverse();
|
| - }
|
| - return localMembersCache;
|
| - }
|
| -
|
| - ClassElementX(String name, Element enclosing, int id, int initialState)
|
| - : super(name, enclosing, id, initialState);
|
| -
|
| - ClassNode parseNode(Compiler compiler);
|
| -
|
| - bool get isMixinApplication => false;
|
| - bool get hasLocalScopeMembers => !localScope.isEmpty;
|
| -
|
| - void addMember(Element element, DiagnosticListener listener) {
|
| - localMembersCache = null;
|
| - localMembersReversed = localMembersReversed.prepend(element);
|
| - addToScope(element, listener);
|
| - }
|
| -
|
| - void addToScope(Element element, DiagnosticListener listener) {
|
| - if (element.isField && element.name == name) {
|
| - listener.reportError(element, MessageKind.MEMBER_USES_CLASS_NAME);
|
| - }
|
| - localScope.add(element, listener);
|
| - }
|
| -
|
| - Element localLookup(String elementName) {
|
| - Element result = localScope.lookup(elementName);
|
| - if (result == null && isPatch) {
|
| - result = origin.localLookup(elementName);
|
| - }
|
| - return result;
|
| - }
|
| -
|
| - void forEachLocalMember(void f(Element member)) {
|
| - localMembers.forEach(f);
|
| - }
|
| -
|
| - bool get hasConstructor {
|
| - // Search in scope to be sure we search patched constructors.
|
| - for (var element in localScope.values) {
|
| - if (element.isConstructor) return true;
|
| - }
|
| - return false;
|
| - }
|
| -
|
| - void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
|
| - // The default constructor, although synthetic, is part of a class' API.
|
| - addMember(constructor, compiler);
|
| - }
|
| -
|
| - List<DartType> computeTypeParameters(Compiler compiler) {
|
| - ClassNode node = parseNode(compiler);
|
| - return createTypeVariables(node.typeParameters);
|
| - }
|
| -
|
| - Scope buildScope() => new ClassScope(enclosingElement.buildScope(), this);
|
| -
|
| - String toString() {
|
| - if (origin != null) {
|
| - return 'patch ${super.toString()}';
|
| - } else if (patch != null) {
|
| - return 'origin ${super.toString()}';
|
| - } else {
|
| - return super.toString();
|
| - }
|
| - }
|
| -}
|
| -
|
| -class MixinApplicationElementX extends BaseClassElementX
|
| - implements MixinApplicationElement {
|
| - final Node node;
|
| - final Modifiers modifiers;
|
| -
|
| - Link<FunctionElement> constructors = new Link<FunctionElement>();
|
| -
|
| - InterfaceType mixinType;
|
| -
|
| - MixinApplicationElementX(String name, Element enclosing, int id,
|
| - this.node, this.modifiers)
|
| - : super(name, enclosing, id, STATE_NOT_STARTED);
|
| -
|
| - ClassElement get mixin => mixinType != null ? mixinType.element : null;
|
| -
|
| - bool get isMixinApplication => true;
|
| - bool get isUnnamedMixinApplication => node is! NamedMixinApplication;
|
| - bool get hasConstructor => !constructors.isEmpty;
|
| - bool get hasLocalScopeMembers => !constructors.isEmpty;
|
| -
|
| - get patch => null;
|
| - get origin => null;
|
| -
|
| - bool get hasNode => true;
|
| -
|
| - Token get position => node.getBeginToken();
|
| -
|
| - Node parseNode(DiagnosticListener listener) => node;
|
| -
|
| - FunctionElement lookupLocalConstructor(String name) {
|
| - for (Link<Element> link = constructors;
|
| - !link.isEmpty;
|
| - link = link.tail) {
|
| - if (link.head.name == name) return link.head;
|
| - }
|
| - return null;
|
| - }
|
| -
|
| - Element localLookup(String name) {
|
| - Element constructor = lookupLocalConstructor(name);
|
| - if (constructor != null) return constructor;
|
| - if (mixin == null) return null;
|
| - Element mixedInElement = mixin.localLookup(name);
|
| - if (mixedInElement == null) return null;
|
| - return mixedInElement.isInstanceMember ? mixedInElement : null;
|
| - }
|
| -
|
| - void forEachLocalMember(void f(Element member)) {
|
| - constructors.forEach(f);
|
| - if (mixin != null) mixin.forEachLocalMember((Element mixedInElement) {
|
| - if (mixedInElement.isInstanceMember) f(mixedInElement);
|
| - });
|
| - }
|
| -
|
| - void addMember(Element element, DiagnosticListener listener) {
|
| - throw new UnsupportedError("Cannot add member to $this.");
|
| - }
|
| -
|
| - void addToScope(Element element, DiagnosticListener listener) {
|
| - listener.internalError(this, 'Cannot add to scope of $this.');
|
| - }
|
| -
|
| - void addConstructor(FunctionElement constructor) {
|
| - constructors = constructors.prepend(constructor);
|
| - }
|
| -
|
| - void setDefaultConstructor(FunctionElement constructor, Compiler compiler) {
|
| - assert(!hasConstructor);
|
| - addConstructor(constructor);
|
| - }
|
| -
|
| - List<DartType> computeTypeParameters(Compiler compiler) {
|
| - NamedMixinApplication named = node.asNamedMixinApplication();
|
| - if (named == null) {
|
| - throw new SpannableAssertionFailure(node,
|
| - "Type variables on unnamed mixin applications must be set on "
|
| - "creation.");
|
| - }
|
| - return createTypeVariables(named.typeParameters);
|
| - }
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitMixinApplicationElement(this);
|
| -}
|
| -
|
| -class LabelDefinitionX implements LabelDefinition {
|
| - final Label label;
|
| - final String labelName;
|
| - final JumpTarget target;
|
| - bool isBreakTarget = false;
|
| - bool isContinueTarget = false;
|
| -
|
| - LabelDefinitionX(Label label, String labelName, this.target)
|
| - : this.label = label,
|
| - this.labelName = labelName;
|
| -
|
| - // In case of a synthetic label, just use [labelName] for identifying the
|
| - // label.
|
| - String get name => label == null ? labelName : label.identifier.source;
|
| -
|
| - void setBreakTarget() {
|
| - isBreakTarget = true;
|
| - target.isBreakTarget = true;
|
| - }
|
| -
|
| - void setContinueTarget() {
|
| - isContinueTarget = true;
|
| - target.isContinueTarget = true;
|
| - }
|
| -
|
| - bool get isTarget => isBreakTarget || isContinueTarget;
|
| -
|
| - String toString() => 'Label:${name}';
|
| -}
|
| -
|
| -class JumpTargetX implements JumpTarget {
|
| - final ExecutableElement executableContext;
|
| - final Node statement;
|
| - final int nestingLevel;
|
| - Link<LabelDefinition> labels = const Link<LabelDefinition>();
|
| - bool isBreakTarget = false;
|
| - bool isContinueTarget = false;
|
| -
|
| - JumpTargetX(this.statement, this.nestingLevel, this.executableContext);
|
| -
|
| - String get name => "target";
|
| -
|
| - bool get isTarget => isBreakTarget || isContinueTarget;
|
| -
|
| - LabelDefinition addLabel(Label label, String labelName) {
|
| - LabelDefinition result = new LabelDefinitionX(label, labelName, this);
|
| - labels = labels.prepend(result);
|
| - return result;
|
| - }
|
| -
|
| - bool get isSwitch => statement is SwitchStatement;
|
| -
|
| - String toString() => 'Target:$statement';
|
| -}
|
| -
|
| -class TypeVariableElementX extends ElementX with AstElementMixin
|
| - implements TypeVariableElement {
|
| - final Node node;
|
| - TypeVariableType typeCache;
|
| - DartType boundCache;
|
| -
|
| - TypeVariableElementX(String name, TypeDeclarationElement enclosing, this.node)
|
| - : super(name, ElementKind.TYPE_VARIABLE, enclosing);
|
| -
|
| - TypeDeclarationElement get typeDeclaration => enclosingElement;
|
| -
|
| - TypeVariableType computeType(compiler) => type;
|
| -
|
| - TypeVariableType get type {
|
| - assert(invariant(this, typeCache != null,
|
| - message: "Type has not been set on $this."));
|
| - return typeCache;
|
| - }
|
| -
|
| - DartType get bound {
|
| - assert(invariant(this, boundCache != null,
|
| - message: "Bound has not been set on $this."));
|
| - return boundCache;
|
| - }
|
| -
|
| - bool get hasNode => true;
|
| -
|
| - Node parseNode(compiler) => node;
|
| -
|
| - String toString() => "${enclosingElement.toString()}.${name}";
|
| -
|
| - Token get position => node.getBeginToken();
|
| -
|
| - accept(ElementVisitor visitor) => visitor.visitTypeVariableElement(this);
|
| -
|
| - // A type variable cannot be patched therefore defines itself.
|
| - AstElement get definingElement => this;
|
| -}
|
| -
|
| -/**
|
| - * A single metadata annotation.
|
| - *
|
| - * For example, consider:
|
| - *
|
| - * class Data {
|
| - * const Data();
|
| - * }
|
| - *
|
| - * const data = const Data();
|
| - *
|
| - * @data
|
| - * class Foo {}
|
| - *
|
| - * @data @data
|
| - * class Bar {}
|
| - *
|
| - * In this example, there are three instances of [MetadataAnnotation]
|
| - * and they correspond each to a location in the source code where
|
| - * there is an at-sign, '@'. The [constant] of each of these instances
|
| - * are the same compile-time constant, [: const Data() :].
|
| - *
|
| - * The mirror system does not have a concept matching this class.
|
| - */
|
| -abstract class MetadataAnnotationX implements MetadataAnnotation {
|
| - /**
|
| - * The compile-time constant which this annotation resolves to.
|
| - * In the mirror system, this would be an object mirror.
|
| - */
|
| - ConstantExpression constant;
|
| - Element annotatedElement;
|
| - int resolutionState;
|
| -
|
| - /**
|
| - * The beginning token of this annotation, or [:null:] if it is synthetic.
|
| - */
|
| - Token get beginToken;
|
| -
|
| - MetadataAnnotationX([this.resolutionState = STATE_NOT_STARTED]);
|
| -
|
| - MetadataAnnotation ensureResolved(Compiler compiler) {
|
| - if (annotatedElement.isClass || annotatedElement.isTypedef) {
|
| - TypeDeclarationElement typeDeclaration = annotatedElement;
|
| - typeDeclaration.ensureResolved(compiler);
|
| - }
|
| - if (resolutionState == STATE_NOT_STARTED) {
|
| - compiler.resolver.resolveMetadataAnnotation(this);
|
| - }
|
| - return this;
|
| - }
|
| -
|
| - Node parseNode(DiagnosticListener listener);
|
| -
|
| - String toString() => 'MetadataAnnotation($constant, $resolutionState)';
|
| -}
|
| -
|
| -/// Metadata annotation on a parameter.
|
| -class ParameterMetadataAnnotation extends MetadataAnnotationX {
|
| - final Metadata metadata;
|
| -
|
| - ParameterMetadataAnnotation(Metadata this.metadata);
|
| -
|
| - Node parseNode(DiagnosticListener listener) => metadata.expression;
|
| -
|
| - Token get beginToken => metadata.getBeginToken();
|
| -
|
| - Token get endToken => metadata.getEndToken();
|
| -
|
| - bool get hasNode => true;
|
| -
|
| - Metadata get node => metadata;
|
| -}
|
| -
|
| -/// Mixin for the implementation of patched elements.
|
| -///
|
| -/// See [:patch_parser.dart:] for a description of the terminology.
|
| -abstract class PatchMixin<E extends Element> implements Element {
|
| - // TODO(johnniwinther): Use type variables when issue 18630 is fixed.
|
| - Element/*E*/ patch = null;
|
| - Element/*E*/ origin = null;
|
| -
|
| - bool get isPatch => origin != null;
|
| - bool get isPatched => patch != null;
|
| -
|
| - bool get isImplementation => !isPatched;
|
| - bool get isDeclaration => !isPatch;
|
| -
|
| - Element/*E*/ get implementation => isPatched ? patch : this;
|
| - Element/*E*/ get declaration => isPatch ? origin : this;
|
| -
|
| - /// Applies a patch to this element. This method must be called at most once.
|
| - void applyPatch(PatchMixin<E> patch) {
|
| - assert(invariant(this, this.patch == null,
|
| - message: "Element is patched twice."));
|
| - assert(invariant(this, this.origin == null,
|
| - message: "Origin element is a patch."));
|
| - assert(invariant(patch, patch.origin == null,
|
| - message: "Element is patched twice."));
|
| - assert(invariant(patch, patch.patch == null,
|
| - message: "Patch element is patched."));
|
| - this.patch = patch;
|
| - patch.origin = this;
|
| - }
|
| -}
|
| -
|
| -/// Abstract implementation of the [AstElement] interface.
|
| -abstract class AstElementMixin implements AstElement {
|
| - /// The element whose node defines this element.
|
| - ///
|
| - /// For patched functions the defining element is the patch element found
|
| - /// through [implementation] since its node define the implementation of the
|
| - /// function. For patched classes the defining element is the origin element
|
| - /// found through [declaration] since its node define the inheritance relation
|
| - /// for the class. For unpatched elements the defining element is the element
|
| - /// itself.
|
| - AstElement get definingElement;
|
| -
|
| - bool get hasResolvedAst => definingElement.hasTreeElements;
|
| -
|
| - ResolvedAst get resolvedAst {
|
| - return new ResolvedAst(declaration,
|
| - definingElement.node, definingElement.treeElements);
|
| - }
|
| -
|
| -}
|
|
|
Chromium Code Reviews
Issue 693183006:
Revert "Move dart2js from sdk/lib/_internal/compiler to pkg/compiler" (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart