Create a new element for generic function types

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 395 matching lines @@
  * An [AbstractClassElementImpl] which is a class.
  */
 class ClassElementImpl extends AbstractClassElementImpl
     with TypeParameterizedElementMixin {
   /**
    * The unlinked representation of the class in the summary.
    */
   final UnlinkedClass _unlinkedClass;
 
   /**
-   * A list containing all of the type parameters defined for this class.
-   */
-  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
-
-  /**
    * The superclass of the class, or `null` for [Object].
    */
   InterfaceType _supertype;
 
   /**
    * The type defined by the class.
    */
   InterfaceType _type;
 
   /**
@@ skipping 462 matching lines @@
   @override
   InterfaceType get type {
     if (_type == null) {
       InterfaceTypeImpl type = new InterfaceTypeImpl(this);
       type.typeArguments = typeParameterTypes;
       _type = type;
     }
     return _type;
   }
 
-  @override
-  TypeParameterizedElementMixin get typeParameterContext => this;
-
-  @override
-  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) {
     _assertNotResynthesized(_unlinkedClass);
     for (TypeParameterElement typeParameter in typeParameters) {
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
     }
-    this._typeParameters = typeParameters;
+    this._typeParameterElements = typeParameters;
   }
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
-      _unlinkedClass.typeParameters;
+      _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 2212 matching lines @@
       ResynthesizerContext context = unit.resynthesizerContext;
       for (int i = 0; i < length; i++) {
         annotations[i] = context.buildAnnotation(this, unlinkedConsts[i]);
       }
       return annotations;
     } else {
       return const <ElementAnnotation>[];
     }
   }
 
+  /**
+   * If the element associated with the given [type] is a generic function type
+   * element, then make it a child of this element. Return the [type] as a
+   * convenience.
+   */
+  DartType _checkElementOfType(DartType type) {
+    Element element = type?.element;
+    if (element is GenericFunctionTypeElementImpl) {
+      element.enclosingElement = this;
+    }
+    return type;
+  }
+
+  /**
+   * If the given [type] is a generic function type, then the element associated
+   * with the type is implicitly a child of this element and should be visted by
+   * the given [visitor].
+   */
+  void _safelyVisitPossibleChild(DartType type, ElementVisitor visitor) {
+    Element element = type?.element;
+    if (element is GenericFunctionTypeElementImpl) {
+      element.accept(visitor);
+    }
+  }
+
   static int findElementIndexUsingIdentical(List items, Object item) {
     int length = items.length;
     for (int i = 0; i < length; i++) {
       if (identical(items[i], item)) {
         return i;
       }
     }
     throw new StateError('Unable to find $item in $items');
   }
 }
@@ skipping 412 matching lines @@
    * element.
    */
   List<LocalVariableElement> _localVariables;
 
   /**
    * A list containing all of the parameters defined by this executable element.
    */
   List<ParameterElement> _parameters;
 
   /**
-   * A list containing all of the type parameters defined for this executable
-   * element.
-   */
-  List<TypeParameterElement> _typeParameters;
-
-  /**
    * The declared return type of this executable element.
    */
   DartType _declaredReturnType;
 
   /**
    * The inferred return type of this executable element.
    */
   DartType _returnType;
 
   /**
@@ skipping 42 matching lines @@
   @override
   int get codeOffset {
     if (serializedExecutable != null) {
       return serializedExecutable.codeRange?.offset;
     }
     return super.codeOffset;
   }
 
   void set declaredReturnType(DartType returnType) {
     _assertNotResynthesized(serializedExecutable);
-    _declaredReturnType = returnType;
+    _declaredReturnType = _checkElementOfType(returnType);
   }
 
   @override
   String get displayName {
     if (serializedExecutable != null) {
       return serializedExecutable.name;
     }
     return super.displayName;
   }
 
@@ skipping 210 matching lines @@
       _declaredReturnType = enclosingUnit.resynthesizerContext.resolveTypeRef(
           serializedExecutable.returnType, typeParameterContext,
           defaultVoid: isSetter && context.analysisOptions.strongMode,
           declaredType: true);
     }
     return _returnType ?? _declaredReturnType;
   }
 
   void set returnType(DartType returnType) {
     _assertNotResynthesized(serializedExecutable);
-    _returnType = returnType;
+    _returnType = _checkElementOfType(returnType);
   }
 
   @override
   FunctionType get type {
     if (serializedExecutable != null) {
       _type ??= new FunctionTypeImpl.elementWithNameAndArgs(
           this, null, allEnclosingTypeParameterTypes, false);
     }
     return _type;
   }
 
   void set type(FunctionType type) {
     _assertNotResynthesized(serializedExecutable);
     _type = type;
   }
 
-  @override
-  TypeParameterizedElementMixin get typeParameterContext => this;
-
-  @override
-  List<TypeParameterElement> get typeParameters {
-    if (serializedExecutable != null) {
-      return super.typeParameters;
-    }
-    return _typeParameters ?? const <TypeParameterElement>[];
-  }
-
   /**
    * Set the type parameters defined by this executable element to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
     _assertNotResynthesized(serializedExecutable);
     for (TypeParameterElement parameter in typeParameters) {
       (parameter as TypeParameterElementImpl).enclosingElement = this;
     }
-    this._typeParameters = typeParameters;
+    this._typeParameterElements = typeParameters;
   }
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
-      serializedExecutable.typeParameters;
+      serializedExecutable?.typeParameters;
 
   @override
   void appendTo(StringBuffer buffer) {
     if (this.kind != ElementKind.GETTER) {
       int typeParameterCount = typeParameters.length;
       if (typeParameterCount > 0) {
         buffer.write('<');
         for (int i = 0; i < typeParameterCount; i++) {
           if (i > 0) {
             buffer.write(", ");
@@ skipping 65 matching lines @@
       if (parameterImpl.identifier == identifier) {
         return parameterImpl;
       }
     }
     return null;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
+    _safelyVisitPossibleChild(returnType, visitor);
     safelyVisitChildren(typeParameters, visitor);
     safelyVisitChildren(parameters, visitor);
-    safelyVisitChildren(_functions, visitor);
-    safelyVisitChildren(_labels, visitor);
-    safelyVisitChildren(_localVariables, visitor);
+    safelyVisitChildren(functions, visitor);
+    safelyVisitChildren(labels, visitor);
+    safelyVisitChildren(localVariables, visitor);
   }
 }
 
 /**
  * A concrete implementation of an [ExportElement].
  */
 class ExportElementImpl extends UriReferencedElementImpl
     implements ExportElement {
   /**
    * The unlinked representation of the export in the summary.
@@ skipping 463 matching lines @@
     this._parameters = parameters;
   }
 
   /**
    * Set the type parameters defined by this type alias to the given
    * [parameters] without becoming the parent of the parameters. This should
    * only be used by the [TypeResolverVisitor] when creating a synthetic type
    * alias.
    */
   void shareTypeParameters(List<TypeParameterElement> typeParameters) {
-    this._typeParameters = typeParameters;
+    this._typeParameterElements = typeParameters;
   }
 
   /**
    * Create and return [FunctionElement]s for the given [unlinkedFunctions].
    */
   static List<FunctionElement> resynthesizeList(
       ExecutableElementImpl executableElement,
       List<UnlinkedExecutable> unlinkedFunctions) {
     int length = unlinkedFunctions.length;
     if (length != 0) {
@@ skipping 108 matching lines @@
    * The return type defined by this type alias.
    */
   DartType _returnType;
 
   /**
    * The type of function defined by this type alias.
    */
   FunctionType _type;
 
   /**
-   * A list containing all of the type parameters defined for this type.
-   */
-  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
-
-  /**
    * Initialize a newly created type alias element to have the given name.
    *
    * [name] the name of this element
    * [nameOffset] the offset of the name of this element in the file that
    *    contains the declaration of this element
    */
   FunctionTypeAliasElementImpl(String name, int nameOffset)
       : _unlinkedTypedef = null,
         super(name, nameOffset);
 
@@ skipping 105 matching lines @@
     if (_unlinkedTypedef != null && _returnType == null) {
       _returnType = enclosingUnit.resynthesizerContext.resolveTypeRef(
           _unlinkedTypedef.returnType, this,
           declaredType: true);
     }
     return _returnType;
   }
 
   void set returnType(DartType returnType) {
     _assertNotResynthesized(_unlinkedTypedef);
-    _returnType = returnType;
+    _returnType = _checkElementOfType(returnType);
   }
 
   @override
   FunctionType get type {
     if (_unlinkedTypedef != null && _type == null) {
       _type = new FunctionTypeImpl.forTypedef(this);
     }
     return _type;
   }
 
   void set type(FunctionType type) {
     _assertNotResynthesized(_unlinkedTypedef);
     _type = type;
   }
 
-  @override
-  TypeParameterizedElementMixin get typeParameterContext => this;
-
-  @override
-  List<TypeParameterElement> get typeParameters {
-    if (_unlinkedTypedef != null) {
-      return super.typeParameters;
-    }
-    return _typeParameters;
-  }
-
   /**
    * Set the type parameters defined for this type to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
     _assertNotResynthesized(_unlinkedTypedef);
     for (TypeParameterElement typeParameter in typeParameters) {
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
     }
-    this._typeParameters = typeParameters;
+    this._typeParameterElements = typeParameters;
   }
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
-      _unlinkedTypedef.typeParameters;
+      _unlinkedTypedef?.typeParameters;
 
   @override
   /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
       visitor.visitFunctionTypeAliasElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("typedef ");
     buffer.write(displayName);
-    int typeParameterCount = _typeParameters.length;
+    List<TypeParameterElement> typeParameters = this.typeParameters;
+    int typeParameterCount = typeParameters.length;
     if (typeParameterCount > 0) {
       buffer.write("<");
       for (int i = 0; i < typeParameterCount; i++) {
         if (i > 0) {
           buffer.write(", ");
         }
-        (_typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
+        (typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
       }
       buffer.write(">");
     }
     buffer.write("(");
     List<ParameterElement> parameterList = parameters;
     int parameterCount = parameterList.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         buffer.write(", ");
       }
@@ skipping 14 matching lines @@
       getNodeMatching((node) => node is FunctionTypeAlias);
 
   @override
   ElementImpl getChild(String identifier) {
     for (ParameterElement parameter in parameters) {
       ParameterElementImpl parameterImpl = parameter;
       if (parameterImpl.identifier == identifier) {
         return parameterImpl;
       }
     }
-    for (TypeParameterElement typeParameter in _typeParameters) {
+    for (TypeParameterElement typeParameter in typeParameters) {
       TypeParameterElementImpl typeParameterImpl = typeParameter;
       if (typeParameterImpl.identifier == identifier) {
         return typeParameterImpl;
       }
     }
     return null;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
+    _safelyVisitPossibleChild(returnType, visitor);
     safelyVisitChildren(parameters, visitor);
     safelyVisitChildren(typeParameters, visitor);
   }
 }
 
 /**
+ * The element used for a generic function type.
+ *
+ * Clients may not extend, implement or mix-in this class.
+ */
+class GenericFunctionTypeElementImpl extends ElementImpl
+    with TypeParameterizedElementMixin
+    implements GenericFunctionTypeElement {
+  /**
+   * The unlinked representation of the generic function type in the summary.
+   */
+  UnlinkedGenericFunctionType _unlinkedGenericFunctionType;
+
+  /**
+   * The declared return type of the function.
+   */
+  DartType _returnType;
+
+  /**
+   * The elements representing the parameters of the function.
+   */
+  List<ParameterElement> _parameters;
+
+  /**
+   * The type defined by this element.
+   */
+  FunctionType _type;
+
+  /**
+   * Initialize a newly created function element to have no name and the given
+   * [nameOffset]. This is used for function expressions, that have no name.
+   */
+  GenericFunctionTypeElementImpl.forOffset(int nameOffset)
+      : super("", nameOffset);
+
+  /**
+   * Initialize from serialized information.
+   */
+  GenericFunctionTypeElementImpl.forSerialized(ElementImpl enclosingElement)
+      : super.forSerialized(enclosingElement);
+
+  @override
+  TypeParameterizedElementMixin get enclosingTypeParameterContext =>
+      (enclosingElement as ElementImpl).typeParameterContext;
+
+  @override
+  ElementKind get kind => ElementKind.GENERIC_FUNCTION_TYPE;
+
+  @override
+  List<ParameterElement> get parameters {
+    if (_unlinkedGenericFunctionType != null) {
+      _parameters ??= ParameterElementImpl.resynthesizeList(
+          _unlinkedGenericFunctionType.parameters, this);
+    }
+    return _parameters ?? const <ParameterElement>[];
+  }
+
+  /**
+   * Set the parameters defined by this function type element to the given
+   * [parameters].
+   */
+  void set parameters(List<ParameterElement> parameters) {
+    _assertNotResynthesized(_unlinkedGenericFunctionType);
+    for (ParameterElement parameter in parameters) {
+      (parameter as ParameterElementImpl).enclosingElement = this;
+    }
+    this._parameters = parameters;
+  }
+
+  @override
+  DartType get returnType {
+    if (_unlinkedGenericFunctionType != null && _returnType == null) {
+      _returnType = enclosingUnit.resynthesizerContext.resolveTypeRef(
+          _unlinkedGenericFunctionType.returnType, typeParameterContext,
+          defaultVoid: false, declaredType: true);
+    }
+    return _returnType;
+  }
+
+  /**
+   * Set the return type defined by this function type element to the given
+   * [returnType].
+   */
+  void set returnType(DartType returnType) {
+    _assertNotResynthesized(_unlinkedGenericFunctionType);
+    _returnType = _checkElementOfType(returnType);
+  }
+
+  @override
+  FunctionType get type {
+    if (_unlinkedGenericFunctionType != null) {
+      _type ??= new FunctionTypeImpl.elementWithNameAndArgs(
+          this, null, allEnclosingTypeParameterTypes, false);
+    }
+    return _type;
+  }
+
+  /**
+   * Set the function type defined by this function type element to the given
+   * [type].
+   */
+  void set type(FunctionType type) {
+    _assertNotResynthesized(_unlinkedGenericFunctionType);
+    _type = type;
+  }
+
+  /**
+   * Set the type parameters defined by this function type element to the given
+   * [typeParameters].
+   */
+  void set typeParameters(List<TypeParameterElement> typeParameters) {
+    _assertNotResynthesized(_unlinkedGenericFunctionType);
+    for (TypeParameterElement parameter in typeParameters) {
+      (parameter as TypeParameterElementImpl).enclosingElement = this;
+    }
+    this._typeParameterElements = typeParameters;
+  }
+
+  @override
+  List<UnlinkedTypeParam> get unlinkedTypeParams =>
+      _unlinkedGenericFunctionType?.typeParameters;
+
+  @override
+  T accept<T>(ElementVisitor<T> visitor) {
+    return visitor.visitGenericFunctionTypeElement(this);
+  }
+
+  @override
+  void appendTo(StringBuffer buffer) {
+    DartType type = returnType;
+    if (type is TypeImpl) {
+      type.appendTo(buffer, new HashSet<TypeImpl>());
+      buffer.write(' Function');
+    } else {
+      buffer.write('Function');
+    }
+    List<TypeParameterElement> typeParams = typeParameters;
+    int typeParameterCount = typeParams.length;
+    if (typeParameterCount > 0) {
+      buffer.write('<');
+      for (int i = 0; i < typeParameterCount; i++) {
+        if (i > 0) {
+          buffer.write(', ');
+        }
+        (typeParams[i] as TypeParameterElementImpl).appendTo(buffer);
+      }
+      buffer.write('>');
+    }
+    List<ParameterElement> params = parameters;
+    buffer.write('(');
+    for (int i = 0; i < params.length; i++) {
+      if (i > 0) {
+        buffer.write(', ');
+      }
+      (params[i] as ParameterElementImpl).appendTo(buffer);
+    }
+    buffer.write(')');
+  }
+
+  @override
+  void visitChildren(ElementVisitor visitor) {
+    super.visitChildren(visitor);
+    _safelyVisitPossibleChild(returnType, visitor);
+    safelyVisitChildren(typeParameters, visitor);
+    safelyVisitChildren(parameters, visitor);
+  }
+}
+
+/**
  * A function type alias of the form
  *     `typedef` identifier typeParameters = genericFunctionType;
  *
  * Clients may not extend, implement or mix-in this class.
  */
 class GenericTypeAliasElementImpl extends ElementImpl
     with TypeParameterizedElementMixin
     implements FunctionTypeAliasElement {
   /**
    * The unlinked representation of the type in the summary.
    */
   final UnlinkedTypedef _unlinkedTypedef;
 
   /**
    * The element representing the generic function type if this is a generic
    * function type alias, or `null` if it isn't.
    */
   FunctionElement _function;
 
   /**
    * The type of function defined by this type alias.
    */
   FunctionType _type;
 
   /**
-   * A list containing all of the type parameters defined for this type.
-   */
-  List<TypeParameterElement> _typeParameters = TypeParameterElement.EMPTY_LIST;
-
-  /**
    * Initialize a newly created type alias element to have the given [name].
    */
   GenericTypeAliasElementImpl.forNode(Identifier name)
       : _unlinkedTypedef = null,
         super.forNode(name);
 
   /**
    * Initialize using the given serialized information.
    */
   GenericTypeAliasElementImpl.forSerialized(
@@ skipping 107 matching lines @@
       _type = new FunctionTypeImpl.forTypedef(this);
     }
     return _type;
   }
 
   void set type(FunctionType type) {
     _assertNotResynthesized(_unlinkedTypedef);
     _type = type;
   }
 
-  @override
-  TypeParameterizedElementMixin get typeParameterContext => this;
-
-  @override
-  List<TypeParameterElement> get typeParameters {
-    if (_unlinkedTypedef != null) {
-      return super.typeParameters;
-    }
-    return _typeParameters;
-  }
-
   /**
    * Set the type parameters defined for this type to the given
    * [typeParameters].
    */
   void set typeParameters(List<TypeParameterElement> typeParameters) {
     _assertNotResynthesized(_unlinkedTypedef);
     for (TypeParameterElement typeParameter in typeParameters) {
       (typeParameter as TypeParameterElementImpl).enclosingElement = this;
     }
-    this._typeParameters = typeParameters;
+    this._typeParameterElements = typeParameters;
   }
 
   @override
   List<UnlinkedTypeParam> get unlinkedTypeParams =>
-      _unlinkedTypedef.typeParameters;
+      _unlinkedTypedef?.typeParameters;
 
   @override
   /*=T*/ accept/*<T>*/(ElementVisitor<dynamic/*=T*/ > visitor) =>
       visitor.visitFunctionTypeAliasElement(this);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write("typedef ");
     buffer.write(displayName);
-    int typeParameterCount = _typeParameters.length;
+    var typeParameters = this.typeParameters;
+    int typeParameterCount = typeParameters.length;
     if (typeParameterCount > 0) {
       buffer.write("<");
       for (int i = 0; i < typeParameterCount; i++) {
         if (i > 0) {
           buffer.write(", ");
         }
-        (_typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
+        (typeParameters[i] as TypeParameterElementImpl).appendTo(buffer);
       }
       buffer.write(">");
     }
     buffer.write(" = ");
     (function as FunctionElementImpl).appendTo(buffer);
   }
 
   @override
   FunctionTypeAlias computeNode() =>
       getNodeMatching((node) => node is GenericTypeAlias);
 
   @override
   ElementImpl getChild(String identifier) {
-    for (TypeParameterElement typeParameter in _typeParameters) {
+    for (TypeParameterElement typeParameter in typeParameters) {
       TypeParameterElementImpl typeParameterImpl = typeParameter;
       if (typeParameterImpl.identifier == identifier) {
         return typeParameterImpl;
       }
     }
     return null;
   }
 
   @override
   void visitChildren(ElementVisitor visitor) {
@@ skipping 2035 matching lines @@
       _declaredType = enclosingUnit.resynthesizerContext.resolveTypeRef(
           _unlinkedVariable.type, typeParameterContext,
           declaredType: true);
     }
     return super.type;
   }
 
   @override
   void set type(DartType type) {
     _assertNotResynthesized(_unlinkedVariable);
-    _type = type;
+    _type = _checkElementOfType(type);
   }
 
   /**
    * Subclasses need this getter, see [ConstVariableElement._unlinkedConst].
    */
   UnlinkedExpr get _unlinkedConst => _unlinkedVariable?.initializer?.bodyExpr;
 }
 
 /**
  * A concrete implementation of a [ParameterElement].
@@ skipping 956 matching lines @@
   DartType get propagatedType {
     if (_unlinkedVariable != null && _propagatedType == null) {
       _propagatedType = enclosingUnit.resynthesizerContext.resolveLinkedType(
           _unlinkedVariable.propagatedTypeSlot, typeParameterContext);
     }
     return _propagatedType;
   }
 
   void set propagatedType(DartType propagatedType) {
     _assertNotResynthesized(_unlinkedVariable);
-    _propagatedType = propagatedType;
+    _propagatedType = _checkElementOfType(propagatedType);
   }
 
   @override
   DartType get type {
     if (isSynthetic && _type == null) {
       if (getter != null) {
         _type = getter.returnType;
       } else if (setter != null) {
         List<ParameterElement> parameters = setter.parameters;
         _type = parameters.isNotEmpty
@@ skipping 268 matching lines @@
       }
       return _bound ??= enclosingUnit.resynthesizerContext.resolveTypeRef(
           _unlinkedTypeParam.bound, enclosingElement,
           instantiateToBoundsAllowed: false, declaredType: true);
     }
     return _bound;
   }
 
   void set bound(DartType bound) {
     _assertNotResynthesized(_unlinkedTypeParam);
-    _bound = bound;
+    _bound = _checkElementOfType(bound);
   }
 
   @override
   int get codeLength {
     if (_unlinkedTypeParam != null) {
       return _unlinkedTypeParam.codeRange?.length;
     }
     return super.codeLength;
   }
 
@@ skipping 60 matching lines @@
       buffer.write(bound);
     }
   }
 }
 
 /**
  * Mixin representing an element which can have type parameters.
  */
 abstract class TypeParameterizedElementMixin
     implements TypeParameterizedElement, ElementImpl {
+  /**
+   * The cached number of type parameters that are in scope in this context, or
+   * `null` if the number has not yet been computed.
+   */
   int _nestingLevel;
+
+  /**
+   * A cached list containing the type parameters declared by this element
+   * directly, or `null` if the elements have not been created yet. This does
+   * not include type parameters that are declared by any enclosing elements.
+   */
   List<TypeParameterElement> _typeParameterElements;
+
+  /**
+   * A cached list containing the type parameter types declared by this element
+   * directly, or `null` if the list has not been computed yet.
+   */
   List<TypeParameterType> _typeParameterTypes;
+
+  /**
+   * A cached list containing all of the type parameter types of this element,
+   * including those declared by this element directly and those declared by any
+   * enclosing elements, or `null` if the list has not been computed yet.
+   */
   List<TypeParameterType> _allTypeParameterTypes;
 
   /**
    * Return all type parameter types of the element that encloses element.
    * Not `null`, but might be empty for top-level and static class members.
    */
   List<TypeParameterType> get allEnclosingTypeParameterTypes {
     return enclosingTypeParameterContext?.allTypeParameterTypes ??
         const <TypeParameterType>[];
   }
@@ skipping 16 matching lines @@
   /**
    * Get the type parameter context enclosing this one, if any.
    */
   TypeParameterizedElementMixin get enclosingTypeParameterContext;
 
   /**
    * The unit in which this element is resynthesized.
    */
   CompilationUnitElementImpl get enclosingUnit;
 
+  @override
+  TypeParameterizedElementMixin get typeParameterContext => this;
+
   /**
    * Find out how many type parameters are in scope in this context.
    */
   int get typeParameterNestingLevel =>
       _nestingLevel ??= unlinkedTypeParams.length +
           (enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0);
 
+  @override
   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(
-            unlinkedTypeParams[i], this, enclosingNestingLevel + i);
+      List<UnlinkedTypeParam> unlinkedParams = unlinkedTypeParams;
+      if (unlinkedParams != null) {
+        int enclosingNestingLevel =
+            enclosingTypeParameterContext?.typeParameterNestingLevel ?? 0;
+        int numTypeParameters = unlinkedParams.length;
+        _typeParameterElements =
+            new List<TypeParameterElement>(numTypeParameters);
+        for (int i = 0; i < numTypeParameters; i++) {
+          _typeParameterElements[i] =
+              new TypeParameterElementImpl.forSerialized(
+                  unlinkedParams[i], this, enclosingNestingLevel + i);
+        }
       }
     }
-    return _typeParameterElements;
+    return _typeParameterElements ?? const <TypeParameterElement>[];
   }
 
   /**
    * Get a list of [TypeParameterType] objects corresponding to the
    * element's type parameters.
    */
   List<TypeParameterType> get typeParameterTypes {
     return _typeParameterTypes ??= typeParameters
         .map((TypeParameterElement e) => e.type)
         .toList(growable: false);
   }
 
   /**
    * Get the [UnlinkedTypeParam]s representing the type parameters declared by
-   * this element.
+   * this element, or `null` if this element isn't from a summary.
    *
    * TODO(scheglov) make private after switching linker to Impl
    */
   List<UnlinkedTypeParam> get unlinkedTypeParams;
 
   /**
    * Convert the given [index] into a type parameter type.
    */
   TypeParameterType getTypeParameterType(int index) {
     List<TypeParameterType> types = typeParameterTypes;
@@ skipping 179 matching lines @@
    * initializers.  However, analyzer also needs to handle incorrect Dart code,
    * in which case there might be some constant variables that lack
    * initializers.
    */
   Expression get constantInitializer => null;
 
   @override
   DartObject get constantValue => evaluationResult?.value;
 
   void set declaredType(DartType type) {
-    _declaredType = type;
+    _declaredType = _checkElementOfType(type);
   }
 
   @override
   String get displayName => name;
 
   /**
    * Return the result of evaluating this variable's initializer as a
    * compile-time constant expression, or `null` if this variable is not a
    * 'const' variable, if it does not have an initializer, or if the compilation
    * unit containing the variable has not been resolved.
@@ skipping 65 matching lines @@
   @override
   bool get isPotentiallyMutatedInScope => false;
 
   @override
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   @override
   DartType get type => _type ?? _declaredType;
 
   void set type(DartType type) {
-    _type = type;
+    _type = _checkElementOfType(type);
   }
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(type);
     buffer.write(" ");
     buffer.write(displayName);
   }
 
   @override
@@ skipping 16 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }