Move TypeParameterizedElementForLink and TypeParameterElementForLink to impl.

pkg/analyzer/lib/src/dart/element/element.dart

 // Copyright (c) 2014, 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 analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 43 matching lines @@
   /**
    * Initialize a newly created pair to have both the [staticElement] and the
    * [propagatedElement].
    */
   AuxiliaryElements(this.staticElement, this.propagatedElement);
 }
 
 /**
  * A concrete implementation of a [ClassElement].
  */
-class ClassElementImpl extends ElementImpl implements ClassElement {
+class ClassElementImpl extends ElementImpl
+    with TypeParameterizedElementMixin
+    implements ClassElement {
   /**
    * The unlinked representation of the class in the summary.
    */
   final UnlinkedClass _unlinkedClass;
 
   /**
    * A list containing all of the accessors (getters and setters) contained in
    * this class.
    */
   List<PropertyAccessorElement> _accessors = PropertyAccessorElement.EMPTY_LIST;
@@ skipping 67 matching lines @@
   /**
    * Initialize a newly created class element to have the given [name].
    */
   ClassElementImpl.forNode(Identifier name)
       : _unlinkedClass = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
-  ClassElementImpl.forSerialized(this._unlinkedClass) : super.forSerialized();
+  ClassElementImpl.forSerialized(
+      ResynthesizerContext resynthesizerContext, this._unlinkedClass)
+      : super.forSerialized(resynthesizerContext);
 
   /**
    * Set whether this class is abstract.
    */
   void set abstract(bool isAbstract) {
     assert(_unlinkedClass == null);
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   @override
@@ skipping 114 matching lines @@
           // supertype, and it is not a mixin application.
           assert(false);
           return false;
         }
         nearestNonMixinClass = nearestNonMixinClass.supertype.element;
       }
     }
     return !nearestNonMixinClass.constructors.any(isSuperConstructorAccessible);
   }
 
+  @override
+  TypeParameterizedElementMixin get enclosingTypeParameterContext => null;
+
   /**
    * Set whether this class is defined by an enum declaration.
    */
   void set enum2(bool isEnum) {
     setModifier(Modifier.ENUM, isEnum);
   }
 
   @override
   List<FieldElement> get fields => _fields;
 
@@ skipping 147 matching lines @@
 
   @override
   int get nameOffset {
     if (_unlinkedClass != null) {
       return _unlinkedClass.nameOffset;
     }
     return super.nameOffset;
   }
 
   @override
-  List<TypeParameterElement> get typeParameters => _typeParameters;
+  List<TypeParameterElement> get typeParameters {
+    if (_unlinkedClass != null) {
+      return super.typeParameters;
+    }
+    return _typeParameters;
+  }
 
   /**
    * Set the type parameters defined for this class to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
+    assert(resynthesizerContext == null);
     for (TypeParameterElement typeParameter in typeParameters) {
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
     }
     this._typeParameters = typeParameters;
   }
 
   @override
+  List<UnlinkedTypeParam> get unlinkedTypeParams =>
+      _unlinkedClass.typeParameters;
+
+  @override
   ConstructorElement get unnamedConstructor {
     for (ConstructorElement element in constructors) {
       String name = element.displayName;
       if (name == null || name.isEmpty) {
         return element;
       }
     }
     return null;
   }
 
@@ skipping 933 matching lines @@
   ConstructorElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created constructor element to have the given [name].
    */
   ConstructorElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
-  ConstructorElementImpl.forSerialized(UnlinkedExecutable serializedExecutable)
-      : super.forSerialized(serializedExecutable);
+  ConstructorElementImpl.forSerialized(
+      ResynthesizerContext resynthesizerContext,
+      UnlinkedExecutable serializedExecutable)
+      : super.forSerialized(resynthesizerContext, serializedExecutable);
 
   /**
    * Set whether this constructor represents a 'const' constructor.
    */
   void set const2(bool isConst) {
     assert(serializedExecutable == null);
     setModifier(Modifier.CONST, isConst);
   }
 
   @override
@@ skipping 395 matching lines @@
 
   final int id = _NEXT_ID++;
 
   /**
    * The enclosing element of this element, or `null` if this element is at the
    * root of the element structure.
    */
   ElementImpl _enclosingElement;
 
   /**
-   * Is `true` is this element is resynthesized from summary.
+   * The context in which this element is resynthesized.

[Paul Berry, 2016/05/17 19:28:02]

Nit: the comment should specify that this value is `null` if the element was not
resynthesized from a summary.

(Otherwise a reader might assume that it is never null).

[scheglov, 2016/05/17 19:42:21]

Done.

    */
-  final bool _isResynthesized;
+  final ResynthesizerContext resynthesizerContext;
 
   /**
    * The name of this element.
    */
   String _name;
 
   /**
    * The offset of the name of this element in the file that contains the
    * declaration of this element.
    */
@@ skipping 43 matching lines @@
 
   /**
    * The length of the element's code, or `null` if the element is synthetic.
    */
   int _codeLength;
 
   /**
    * Initialize a newly created element to have the given [name] at the given
    * [_nameOffset].
    */
-  ElementImpl(String name, this._nameOffset) : _isResynthesized = false {
+  ElementImpl(String name, this._nameOffset) : resynthesizerContext = null {
     this._name = StringUtilities.intern(name);
   }
 
   /**
    * Initialize a newly created element to have the given [name].
    */
   ElementImpl.forNode(Identifier name)
       : this(name == null ? "" : name.name, name == null ? -1 : name.offset);
 
   /**
    * Initialize from serialized information.
    */
-  ElementImpl.forSerialized() : _isResynthesized = true;
+  ElementImpl.forSerialized(this.resynthesizerContext);
 
   /**
    * The length of the element's code, or `null` if the element is synthetic.
    */
   int get codeLength => _codeLength;
 
   /**
    * The offset of the beginning of the element's code in the file that contains
    * the element, or `null` if the element is synthetic.
    */
@@ skipping 18 matching lines @@
     return null;
   }
 
   @override
   String get documentationComment => _docComment;
 
   /**
    * The documentation comment source for this element.
    */
   void set documentationComment(String doc) {
-    assert(!_isResynthesized);
+    assert(resynthesizerContext == null);
     _docComment = doc?.replaceAll('\r\n', '\n');
   }
 
   @override
   Element get enclosingElement => _enclosingElement;
 
   /**
    * Set the enclosing element of this element to the given [element].
    *
    * Throws [FrozenHashCodeException] if the hashCode can't be changed.
@@ skipping 270 matching lines @@
       for (Element child in children) {
         child.accept(visitor);
       }
     }
   }
 
   /**
    * Set the code range for this element.
    */
   void setCodeRange(int offset, int length) {
-    assert(!_isResynthesized);
+    assert(resynthesizerContext == null);
     _codeOffset = offset;
     _codeLength = length;
   }
 
   /**
    * Set the documentation comment source range for this element.
    */
   void setDocRange(int offset, int length) {
-    assert(!_isResynthesized);
+    assert(resynthesizerContext == null);
     _docRangeOffset = offset;
     _docRangeLength = length;
   }
 
   /**
    * Set whether the given [modifier] is associated with this element to
    * correspond to the given [value].
    */
   void setModifier(Modifier modifier, bool value) {
     _modifiers = BooleanArray.setEnum(_modifiers, modifier, value);
@@ skipping 251 matching lines @@
   /**
    * Initialize a newly created executable element to have the given [name].
    */
   ExecutableElementImpl.forNode(Identifier name)
       : serializedExecutable = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
-  ExecutableElementImpl.forSerialized(this.serializedExecutable)
-      : super.forSerialized();
+  ExecutableElementImpl.forSerialized(
+      ResynthesizerContext resynthesizerContext, this.serializedExecutable)
+      : super.forSerialized(resynthesizerContext);
 
   /**
    * Set whether this executable element's body is asynchronous.
    */
   void set asynchronous(bool isAsynchronous) {
     assert(serializedExecutable == null);
     setModifier(Modifier.ASYNCHRONOUS, isAsynchronous);
   }
 
   @override
@@ skipping 437 matching lines @@
 
   /**
    * Initialize a newly created function element to have no name and the given
    * [offset]. This is used for function expressions, that have no name.
    */
   FunctionElementImpl.forOffset(int nameOffset) : super("", nameOffset);
 
   /**
    * Initialize using the given serialized information.
    */
-  FunctionElementImpl.forSerialized(UnlinkedExecutable serializedExecutable)
-      : super.forSerialized(serializedExecutable);
+  FunctionElementImpl.forSerialized(ResynthesizerContext resynthesizerContext,
+      UnlinkedExecutable serializedExecutable)
+      : super.forSerialized(resynthesizerContext, serializedExecutable);
 
   /**
    * Synthesize an unnamed function element that takes [parameters] and returns
    * [returnType].
    */
   FunctionElementImpl.synthetic(
       List<ParameterElement> parameters, DartType returnType)
       : super("", -1) {
     synthetic = true;
     this.returnType = returnType;
@@ skipping 119 matching lines @@
   /**
    * Initialize a newly created type alias element to have the given [name].
    */
   FunctionTypeAliasElementImpl.forNode(Identifier name)
       : _unlinkedTypedef = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
-  FunctionTypeAliasElementImpl.forSerialized(this._unlinkedTypedef)
-      : super.forSerialized();
+  FunctionTypeAliasElementImpl.forSerialized(
+      ResynthesizerContext resynthesizerContext, this._unlinkedTypedef)
+      : super.forSerialized(resynthesizerContext);
 
   @override
   int get codeLength {
     if (_unlinkedTypedef != null) {
       return _unlinkedTypedef.codeRange?.length;
     }
     return super.codeLength;
   }
 
   @override
@@ skipping 972 matching lines @@
   MethodElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created method element to have the given [name].
    */
   MethodElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
-  MethodElementImpl.forSerialized(UnlinkedExecutable serializedExecutable)
-      : super.forSerialized(serializedExecutable);
+  MethodElementImpl.forSerialized(ResynthesizerContext resynthesizerContext,
+      UnlinkedExecutable serializedExecutable)
+      : super.forSerialized(resynthesizerContext, serializedExecutable);
 
   /**
    * Set whether this method is abstract.
    */
   void set abstract(bool isAbstract) {
     assert(serializedExecutable == null);
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   @override
@@ skipping 707 matching lines @@
   /**
    * Initialize a newly created property accessor element to have the given
    * [name].
    */
   PropertyAccessorElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   PropertyAccessorElementImpl.forSerialized(
+      ResynthesizerContext resynthesizerContext,
       UnlinkedExecutable serializedExecutable)
-      : super.forSerialized(serializedExecutable);
+      : super.forSerialized(resynthesizerContext, serializedExecutable);
 
   /**
    * Initialize a newly created synthetic property accessor element to be
    * associated with the given [variable].
    */
   PropertyAccessorElementImpl.forVariable(PropertyInducingElementImpl variable)
       : super(variable.name, variable.nameOffset) {
     this.variable = variable;
     static = variable.isStatic;
     synthetic = true;
@@ skipping 169 matching lines @@
    */
   PropertyInducingElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created element to have the given [name].
    */
   PropertyInducingElementImpl.forNode(Identifier name) : super.forNode(name);
 }
 
 /**
+ * The context in which elements are resynthesized.
+ */
+abstract class ResynthesizerContext {
+  /**
+   * Resolve an [EntityRef] into a type.  If the reference is
+   * unresolved, return [DynamicTypeImpl.instance].
+   *
+   * TODO(paulberry): or should we have a class representing an
+   * unresolved type, for consistency with the full element model?
+   */
+  DartType resolveTypeRef(
+      EntityRef type, TypeParameterizedElementMixin typeParameterContext,
+      {bool defaultVoid: false, bool instantiateToBoundsAllowed: true});
+}
+
+/**
  * A concrete implementation of a [ShowElementCombinator].
  */
 class ShowElementCombinatorImpl implements ShowElementCombinator {
   /**
    * The names that are to be made visible in the importing library if they are
    * defined in the imported library.
    */
   List<String> shownNames = StringUtilities.EMPTY_ARRAY;
 
   /**
@@ skipping 52 matching lines @@
   VariableDeclaration computeNode() =>
       getNodeMatching((node) => node is VariableDeclaration);
 }
 
 /**
  * A concrete implementation of a [TypeParameterElement].
  */
 class TypeParameterElementImpl extends ElementImpl
     implements TypeParameterElement {
   /**
+   * The unlinked representation of the type parameter in the summary.
+   */
+  final UnlinkedTypeParam _unlinkedTypeParam;
+
+  /**
+   * Get the type parameter context enclosing this one, if any.
+   */
+  final TypeParameterizedElementMixin _enclosingTypeParameterContext;

[Brian Wilkerson, 2016/05/17 19:42:26]

It looks wrong to me to use a mixin as a type this way. I'm guessing we can't
just use TypeParameterizedElement instead, and I suppose it would be foolish to
define an interface to avoid it, but it messes with my concept of what a mixin
ought to be.

+
+  /**
+   * The number of type parameters whose scope overlaps this one, and which are
+   * declared earlier in the file.
+   *
+   * TODO(scheglov) make private?
+   */
+  final int nestingLevel;
+
+  /**
    * The type defined by this type parameter.
    */
-  TypeParameterType type;
+  TypeParameterType _type;
 
   /**
    * The type representing the bound associated with this parameter, or `null`
    * if this parameter does not have an explicit bound.
    */
-  DartType bound;
+  DartType _bound;
 
   /**
    * Initialize a newly created method element to have the given [name] and
    * [offset].
    */
-  TypeParameterElementImpl(String name, int offset) : super(name, offset);
+  TypeParameterElementImpl(String name, int offset)
+      : _unlinkedTypeParam = null,
+        nestingLevel = null,
+        _enclosingTypeParameterContext = null,
+        super(name, offset);
 
   /**
    * Initialize a newly created type parameter element to have the given [name].
    */
-  TypeParameterElementImpl.forNode(Identifier name) : super.forNode(name);
+  TypeParameterElementImpl.forNode(Identifier name)
+      : _unlinkedTypeParam = null,
+        nestingLevel = null,
+        _enclosingTypeParameterContext = null,
+        super.forNode(name);
+
+  /**
+   * Initialize using the given serialized information.
+   */
+  TypeParameterElementImpl.forSerialized(
+      ResynthesizerContext resynthesizerContext,
+      this._unlinkedTypeParam,
+      this._enclosingTypeParameterContext,
+      this.nestingLevel)
+      : super.forSerialized(resynthesizerContext);
 
   /**
    * Initialize a newly created synthetic type parameter element to have the
    * given [name], and with [synthetic] set to true.
    */
-  TypeParameterElementImpl.synthetic(String name) : super(name, -1) {
+  TypeParameterElementImpl.synthetic(String name)
+      : _unlinkedTypeParam = null,
+        nestingLevel = null,
+        _enclosingTypeParameterContext = null,
+        super(name, -1) {
     synthetic = true;
   }
 
+  DartType get bound {
+    if (_unlinkedTypeParam != null) {
+      if (_unlinkedTypeParam.bound == null) {
+        return null;
+      }
+      return _bound ??= resynthesizerContext.resolveTypeRef(

[Brian Wilkerson, 2016/05/17 19:42:26]

Is it safe to assume here that "resynthesizerContext" is not null?

+          _unlinkedTypeParam.bound, enclosingElement,
+          instantiateToBoundsAllowed: false);
+    }
+    return _bound;
+  }
+
+  void set bound(DartType bound) {
+    assert(resynthesizerContext == null);
+    _bound = bound;
+  }
+
+  @override
+  int get codeLength {
+    if (_unlinkedTypeParam != null) {
+      return _unlinkedTypeParam.codeRange?.length;
+    }
+    return super.codeLength;
+  }
+
+  @override
+  int get codeOffset {
+    if (_unlinkedTypeParam != null) {
+      return _unlinkedTypeParam.codeRange?.offset;
+    }
+    return super.codeOffset;
+  }
+
+  @override
+  String get displayName => name;
+
+  @override
+  Element get enclosingElement {
+    if (_unlinkedTypeParam != null) {
+      return _enclosingTypeParameterContext;
+    }
+    return super.enclosingElement;
+  }
+
   @override
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
   @override
+  String get name {
+    if (_unlinkedTypeParam != null) {
+      return _unlinkedTypeParam.name;
+    }
+    return super.name;
+  }
+
+  @override
+  int get nameOffset {
+    if (_unlinkedTypeParam != null) {
+      return _unlinkedTypeParam.nameOffset;
+    }
+    return super.nameOffset;
+  }
+
+  TypeParameterType get type {
+    if (_unlinkedTypeParam != null) {
+      _type ??= new TypeParameterTypeImpl(this);
+    }
+    return _type;
+  }
+
+  void set type(TypeParameterType type) {
+    _type = type;
+  }
+
+  @override
   accept(ElementVisitor visitor) => visitor.visitTypeParameterElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(displayName);
     if (bound != null) {
       buffer.write(" extends ");
       buffer.write(bound);
     }
   }
 }
 
 /**
+ * Mixin representing an element which can have type parameters.
+ */
+abstract class TypeParameterizedElementMixin
+    implements TypeParameterizedElement {
+  List<TypeParameterType> _typeParameterTypes;
+  List<TypeParameterElement> _typeParameterElements;
+  int _nestingLevel;
+
+  /**
+   * Get the type parameter context enclosing this one, if any.
+   */
+  TypeParameterizedElementMixin get enclosingTypeParameterContext;
+
+  /**
+   * The context in which this element is resynthesized.
+   */
+  ResynthesizerContext get resynthesizerContext;
+
+  /**
+   * Find out how many type parameters are in scope in this context.
+   */
+  int get typeParameterNestingLevel =>
+      _nestingLevel ??= unlinkedTypeParams.length +
+          (enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0);
+
+  List<TypeParameterElement> get typeParameters {
+    if (_typeParameterElements == null) {
+      int enclosingNestingLevel =
+          enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0;
+      int numTypeParameters = unlinkedTypeParams.length;
+      _typeParameterElements =
+          new List<TypeParameterElement>(numTypeParameters);
+      for (int i = 0; i < numTypeParameters; i++) {
+        _typeParameterElements[i] = new TypeParameterElementImpl.forSerialized(
+            resynthesizerContext,
+            unlinkedTypeParams[i],
+            this,
+            enclosingNestingLevel + i);
+      }
+    }
+    return _typeParameterElements;
+  }
+
+  /**
+   * Get a list of [TypeParameterType] objects corresponding to the
+   * element's type parameters.
+   */
+  List<TypeParameterType> get typeParameterTypes {
+    if (_typeParameterTypes == null) {
+      _typeParameterTypes =
+          typeParameters.map((TypeParameterElement e) => e.type).toList();
+    }
+    return _typeParameterTypes;
+  }
+
+  /**
+   * Get the [UnlinkedTypeParam]s representing the type parameters declared by
+   * this element.
+   *
+   * TODO(scheglov) make private after MLI

[Paul Berry, 2016/05/17 19:28:02]

Can you expand on this comment?  It's not clear to me what "MLI" refers to.

[scheglov, 2016/05/17 19:42:21]

Done.

+   */
+  List<UnlinkedTypeParam> get unlinkedTypeParams;
+
+  /**
+   * Convert the given [index] into a type parameter type.
+   */
+  TypeParameterType getTypeParameterType(int index) {
+    List<TypeParameterType> types = typeParameterTypes;
+    if (index <= types.length) {
+      return types[types.length - index];
+    } else if (enclosingTypeParameterContext != null) {
+      return enclosingTypeParameterContext
+          .getTypeParameterType(index - types.length);
+    } else {
+      // If we get here, it means that a summary contained a type parameter index
+      // that was out of range.
+      throw new RangeError('Invalid type parameter index');
+    }
+  }
+
+  /**
+   * Find out if the given [typeParameter] is in scope in this context.
+   */
+  bool isTypeParameterInScope(TypeParameterElement typeParameter) {
+    if (typeParameter.enclosingElement == this) {
+      return true;
+    } else if (enclosingTypeParameterContext != null) {
+      return enclosingTypeParameterContext
+          .isTypeParameterInScope(typeParameter);
+    } else {
+      return false;
+    }
+  }
+}
+
+/**
  * A concrete implementation of a [UriReferencedElement].
  */
 abstract class UriReferencedElementImpl extends ElementImpl
     implements UriReferencedElement {
   /**
    * The offset of the URI in the file, may be `-1` if synthetic.
    */
   int uriOffset = -1;
 
   /**
@@ skipping 152 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }