Create ElementAnnotation objects prior to resolution.

pkg/analyzer/lib/src/dart/element/builder.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.builder;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 21 matching lines @@
    * if the element could not be built.  [librarySource] is the source for the
    * containing library.
    */
   CompilationUnitElementImpl buildCompilationUnit(
       Source source, CompilationUnit unit, Source librarySource) {
     return PerformanceStatistics.resolve.makeCurrentWhile(() {
       if (unit == null) {
         return null;
       }
       ElementHolder holder = new ElementHolder();
-      ElementBuilder builder = new ElementBuilder(holder);
-      unit.accept(builder);
       CompilationUnitElementImpl element =
           new CompilationUnitElementImpl(source.shortName);
+      ElementBuilder builder = new ElementBuilder(holder, element);
+      unit.accept(builder);
       element.accessors = holder.accessors;
       element.enums = holder.enums;
       element.functions = holder.functions;
       element.source = source;
       element.librarySource = librarySource;
       element.typeAliases = holder.typeAliases;
       element.types = holder.types;
       element.topLevelVariables = holder.topLevelVariables;
       unit.element = element;
       holder.validate();
@@ skipping 104 matching lines @@
 
   @override
   Object visitExportDirective(ExportDirective node) {
     Source exportedSource = node.source;
     if (exportedSource != null && context.exists(exportedSource)) {
       // The exported source will be null if the URI in the export
       // directive was invalid.
       LibraryElement exportedLibrary = exportLibraryMap[exportedSource];
       if (exportedLibrary != null) {
         ExportElementImpl exportElement = new ExportElementImpl(node.offset);
+        exportElement.metadata = _getElementAnnotations(node.metadata);
         StringLiteral uriLiteral = node.uri;
         if (uriLiteral != null) {
           exportElement.uriOffset = uriLiteral.offset;
           exportElement.uriEnd = uriLiteral.end;
         }
         exportElement.uri = node.uriContent;
         exportElement.combinators = _buildCombinators(node);
         exportElement.exportedLibrary = exportedLibrary;
         _setDoc(exportElement, node);
         node.element = exportElement;
@@ skipping 20 matching lines @@
     Source importedSource = node.source;
     if (importedSource != null && context.exists(importedSource)) {
       // The imported source will be null if the URI in the import
       // directive was invalid.
       LibraryElement importedLibrary = importLibraryMap[importedSource];
       if (importedLibrary != null) {
         if (importedLibrary.isDartCore) {
           explicitlyImportsCore = true;
         }
         ImportElementImpl importElement = new ImportElementImpl(node.offset);
+        importElement.metadata = _getElementAnnotations(node.metadata);
         StringLiteral uriLiteral = node.uri;
         if (uriLiteral != null) {
           importElement.uriOffset = uriLiteral.offset;
           importElement.uriEnd = uriLiteral.end;
         }
         importElement.uri = uriContent;
         importElement.deferred = node.deferredKeyword != null;
         importElement.combinators = _buildCombinators(node);
         importElement.importedLibrary = importedLibrary;
         _setDoc(importElement, node);
@@ skipping 16 matching lines @@
               ? StaticWarningCode.IMPORT_OF_NON_LIBRARY
               : CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY);
           errors.add(new AnalysisError(importedSource, uriLiteral.offset,
               uriLiteral.length, errorCode, [uriLiteral.toSource()]));
         }
       }
     }
     return null;
   }
 
+  @override
+  Object visitLibraryDirective(LibraryDirective node) {
+    (node.element as LibraryElementImpl)?.metadata =
+        _getElementAnnotations(node.metadata);
+    return null;
+  }
+
+  @override
+  Object visitPartDirective(PartDirective node) {
+    (node.element as CompilationUnitElementImpl)?.metadata =
+        _getElementAnnotations(node.metadata);
+    return null;
+  }
+
+  /**
+   * Gather a list of the [ElementAnnotation]s referred to by the [Annotation]s
+   * in [metadata].
+   */
+  List<ElementAnnotation> _getElementAnnotations(
+      NodeList<Annotation> metadata) {
+    if (metadata.isEmpty) {
+      return ElementAnnotation.EMPTY_LIST;
+    }
+    return metadata.map((Annotation a) => a.elementAnnotation).toList();
+  }
+
   /**
    * If the given [node] has a documentation comment, remember its content
    * and range into the given [element].
    */
   void _setDoc(ElementImpl element, AnnotatedNode node) {
     Comment comment = node.documentationComment;
     if (comment != null && comment.isDocumentation) {
       element.documentationComment =
           comment.tokens.map((Token t) => t.lexeme).join('\n');
       element.setDocRange(comment.offset, comment.length);
@@ skipping 14 matching lines @@
     return namespaceCombinatorBuilder.combinators;
   }
 }
 
 /**
  * Instances of the class `ElementBuilder` traverse an AST structure and build the element
  * model representing the AST structure.
  */
 class ElementBuilder extends RecursiveAstVisitor<Object> {
   /**
+   * The compilation unit element into which the elements being built will be
+   * stored.
+   */
+  final CompilationUnitElement compilationUnitElement;
+
+  /**
    * The element holder associated with the element that is currently being built.
    */
   ElementHolder _currentHolder;
 
   /**
    * A flag indicating whether a variable declaration is in the context of a field declaration.
    */
   bool _inFieldContext = false;
 
   /**
@@ skipping 13 matching lines @@
    * A table mapping field names to field elements for the fields defined in the current class, or
    * `null` if we are not in the scope of a class.
    */
   HashMap<String, FieldElement> _fieldMap;
 
   /**
    * Initialize a newly created element builder to build the elements for a compilation unit.
    *
    * @param initialHolder the element holder associated with the compilation unit being built
    */
-  ElementBuilder(ElementHolder initialHolder) {
+  ElementBuilder(ElementHolder initialHolder, this.compilationUnitElement) {
     _currentHolder = initialHolder;
   }
 
   @override
   Object visitBlock(Block node) {
     bool wasInField = _inFieldContext;
     _inFieldContext = false;
     try {
       node.visitChildren(this);
     } finally {
@@ skipping 43 matching lines @@
       _buildFieldMap(holder.fieldsWithoutFlushing);
       int count = nonFields.length;
       for (int i = 0; i < count; i++) {
         nonFields[i].accept(this);
       }
     } finally {
       _currentHolder = previousHolder;
     }
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl.forNode(className);
+    element.metadata = _createElementAnnotations(node.metadata);
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     List<DartType> typeArguments = _createTypeParameterTypes(typeParameters);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     element.typeParameters = typeParameters;
     _setDoc(element, node);
     element.abstract = node.isAbstract;
     element.accessors = holder.accessors;
     List<ConstructorElement> constructors = holder.constructors;
@@ skipping 28 matching lines @@
     ClassElement classElement = node.element;
     _buildFieldMap(classElement.fields);
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl.forNode(className);
+    element.metadata = _createElementAnnotations(node.metadata);
     element.abstract = node.abstractKeyword != null;
     element.mixinApplication = true;
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     element.typeParameters = typeParameters;
     List<DartType> typeArguments = _createTypeParameterTypes(typeParameters);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl(element);
     interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     _setDoc(element, node);
     _currentHolder.addType(element);
     className.staticElement = element;
     holder.validate();
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       _visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     FunctionBody body = node.body;
     SimpleIdentifier constructorName = node.name;
     ConstructorElementImpl element =
         new ConstructorElementImpl.forNode(constructorName);
+    element.metadata = _createElementAnnotations(node.metadata);
     _setDoc(element, node);
     if (node.externalKeyword != null) {
       element.external = true;
     }
     if (node.factoryKeyword != null) {
       element.factory = true;
     }
     element.functions = holder.functions;
     element.labels = holder.labels;
     element.localVariables = holder.localVariables;
@@ skipping 20 matching lines @@
     }
     holder.validate();
     return null;
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     LocalVariableElementImpl element =
         new LocalVariableElementImpl.forNode(variableName);
+    element.metadata = _createElementAnnotations(node.metadata);
     ForEachStatement statement = node.parent as ForEachStatement;
     int declarationEnd = node.offset + node.length;
     int statementEnd = statement.offset + statement.length;
     element.setVisibleRange(declarationEnd, statementEnd - declarationEnd - 1);
     element.const3 = node.isConst;
     element.final2 = node.isFinal;
     if (node.type == null) {
       element.hasImplicitType = true;
     }
     _currentHolder.addLocalVariable(element);
@@ skipping 44 matching lines @@
     parameterName.staticElement = parameter;
     normalParameter.accept(this);
     holder.validate();
     return null;
   }
 
   @override
   Object visitEnumDeclaration(EnumDeclaration node) {
     SimpleIdentifier enumName = node.name;
     ClassElementImpl enumElement = new ClassElementImpl.forNode(enumName);
+    enumElement.metadata = _createElementAnnotations(node.metadata);
     enumElement.enum2 = true;
     _setDoc(enumElement, node);
     InterfaceTypeImpl enumType = new InterfaceTypeImpl(enumElement);
     enumElement.type = enumType;
     // The equivalent code for enums in the spec shows a single constructor,
     // but that constructor is not callable (since it is a compile-time error
     // to subclass, mix-in, implement, or explicitly instantiate an enum).  So
     // we represent this as having no constructors.
     enumElement.constructors = ConstructorElement.EMPTY_LIST;
     _currentHolder.addEnum(enumElement);
     enumName.staticElement = enumElement;
     return super.visitEnumDeclaration(node);
   }
 
   @override
+  Object visitExportDirective(ExportDirective node) {
+    _createElementAnnotations(node.metadata);
+    return super.visitExportDirective(node);
+  }
+
+  @override
   Object visitFieldDeclaration(FieldDeclaration node) {
     bool wasInField = _inFieldContext;
     _inFieldContext = true;
     try {
       node.visitChildren(this);
     } finally {
       _inFieldContext = wasInField;
     }
     return null;
   }
@@ skipping 15 matching lines @@
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     //
     // The children of this parameter include any parameters defined on the type
     // of this parameter.
     //
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     ParameterElementImpl element = node.element;
+    element.metadata = _createElementAnnotations(node.metadata);
     element.parameters = holder.parameters;
     element.typeParameters = holder.typeParameters;
     holder.validate();
     return null;
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionExpression expression = node.functionExpression;
     if (expression != null) {
       ElementHolder holder = new ElementHolder();
       bool wasInFunction = _inFunction;
       _inFunction = true;
       try {
         _visitChildren(holder, node);
       } finally {
         _inFunction = wasInFunction;
       }
       FunctionBody body = expression.body;
       Token property = node.propertyKeyword;
       if (property == null || _inFunction) {
         SimpleIdentifier functionName = node.name;
         FunctionElementImpl element =
             new FunctionElementImpl.forNode(functionName);
+        element.metadata = _createElementAnnotations(node.metadata);
         _setDoc(element, node);
         if (node.externalKeyword != null) {
           element.external = true;
         }
         element.functions = holder.functions;
         element.labels = holder.labels;
         element.localVariables = holder.localVariables;
         element.parameters = holder.parameters;
         element.typeParameters = holder.typeParameters;
         if (body.isAsynchronous) {
@@ skipping 27 matching lines @@
             .getTopLevelVariable(propertyName) as TopLevelVariableElementImpl;
         if (variable == null) {
           variable = new TopLevelVariableElementImpl(node.name.name, -1);
           variable.final2 = true;
           variable.synthetic = true;
           _currentHolder.addTopLevelVariable(variable);
         }
         if (node.isGetter) {
           PropertyAccessorElementImpl getter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          getter.metadata = _createElementAnnotations(node.metadata);
           _setDoc(getter, node);
           if (node.externalKeyword != null) {
             getter.external = true;
           }
           getter.functions = holder.functions;
           getter.labels = holder.labels;
           getter.localVariables = holder.localVariables;
           if (body.isAsynchronous) {
             getter.asynchronous = true;
           }
           if (body.isGenerator) {
             getter.generator = true;
           }
           getter.variable = variable;
           getter.getter = true;
           getter.static = true;
           variable.getter = getter;
           if (node.returnType == null) {
             getter.hasImplicitReturnType = true;
           }
           _currentHolder.addAccessor(getter);
           expression.element = getter;
           propertyNameNode.staticElement = getter;
         } else {
           PropertyAccessorElementImpl setter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          setter.metadata = _createElementAnnotations(node.metadata);
           _setDoc(setter, node);
           if (node.externalKeyword != null) {
             setter.external = true;
           }
           setter.functions = holder.functions;
           setter.labels = holder.labels;
           setter.localVariables = holder.localVariables;
           setter.parameters = holder.parameters;
           if (body.isAsynchronous) {
             setter.asynchronous = true;
@@ skipping 70 matching lines @@
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     SimpleIdentifier aliasName = node.name;
     List<ParameterElement> parameters = holder.parameters;
     List<TypeParameterElement> typeParameters = holder.typeParameters;
     FunctionTypeAliasElementImpl element =
         new FunctionTypeAliasElementImpl.forNode(aliasName);
+    element.metadata = _createElementAnnotations(node.metadata);
     _setDoc(element, node);
     element.parameters = parameters;
     element.typeParameters = typeParameters;
     _createTypeParameterTypes(typeParameters);
     element.type = new FunctionTypeImpl.forTypedef(element);
     _currentHolder.addTypeAlias(element);
     aliasName.staticElement = element;
     holder.validate();
     return null;
   }
 
   @override
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter =
           new ParameterElementImpl.forNode(parameterName);
       parameter.parameterKind = node.kind;
       _setParameterVisibleRange(node, parameter);
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
     //
     // The children of this parameter include any parameters defined on the type
     //of this parameter.
     //
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     ParameterElementImpl element = node.element;
+    element.metadata = _createElementAnnotations(node.metadata);
     element.parameters = holder.parameters;
     element.typeParameters = holder.typeParameters;
     holder.validate();
     return null;
   }
 
   @override
+  Object visitImportDirective(ImportDirective node) {
+    _createElementAnnotations(node.metadata);
+    return super.visitImportDirective(node);
+  }
+
+  @override
   Object visitLabeledStatement(LabeledStatement node) {
     bool onSwitchStatement = node.statement is SwitchStatement;
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element =
           new LabelElementImpl(labelName, onSwitchStatement, false);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
     return super.visitLabeledStatement(node);
   }
 
   @override
+  Object visitLibraryDirective(LibraryDirective node) {
+    _createElementAnnotations(node.metadata);
+    return super.visitLibraryDirective(node);
+  }
+
+  @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     try {
       ElementHolder holder = new ElementHolder();
       bool wasInFunction = _inFunction;
       _inFunction = true;
       try {
         _visitChildren(holder, node);
       } finally {
         _inFunction = wasInFunction;
       }
       bool isStatic = node.isStatic;
       Token property = node.propertyKeyword;
       FunctionBody body = node.body;
       if (property == null) {
         SimpleIdentifier methodName = node.name;
         String nameOfMethod = methodName.name;
         if (nameOfMethod == TokenType.MINUS.lexeme &&
             node.parameters.parameters.length == 0) {
           nameOfMethod = "unary-";
         }
         MethodElementImpl element =
             new MethodElementImpl(nameOfMethod, methodName.offset);
+        element.metadata = _createElementAnnotations(node.metadata);
         _setDoc(element, node);
         element.abstract = node.isAbstract;
         if (node.externalKeyword != null) {
           element.external = true;
         }
         element.functions = holder.functions;
         element.labels = holder.labels;
         element.localVariables = holder.localVariables;
         element.parameters = holder.parameters;
         element.static = isStatic;
@@ skipping 17 matching lines @@
         if (field == null) {
           field = new FieldElementImpl(node.name.name, -1);
           field.final2 = true;
           field.static = isStatic;
           field.synthetic = true;
           _currentHolder.addField(field);
         }
         if (node.isGetter) {
           PropertyAccessorElementImpl getter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          getter.metadata = _createElementAnnotations(node.metadata);
           _setDoc(getter, node);
           if (node.externalKeyword != null) {
             getter.external = true;
           }
           getter.functions = holder.functions;
           getter.labels = holder.labels;
           getter.localVariables = holder.localVariables;
           if (body.isAsynchronous) {
             getter.asynchronous = true;
           }
           if (body.isGenerator) {
             getter.generator = true;
           }
           getter.variable = field;
           getter.abstract = node.isAbstract;
           getter.getter = true;
           getter.static = isStatic;
           field.getter = getter;
           if (node.returnType == null) {
             getter.hasImplicitReturnType = true;
           }
           _currentHolder.addAccessor(getter);
           propertyNameNode.staticElement = getter;
         } else {
           PropertyAccessorElementImpl setter =
               new PropertyAccessorElementImpl.forNode(propertyNameNode);
+          setter.metadata = _createElementAnnotations(node.metadata);
           _setDoc(setter, node);
           if (node.externalKeyword != null) {
             setter.external = true;
           }
           setter.functions = holder.functions;
           setter.labels = holder.labels;
           setter.localVariables = holder.localVariables;
           setter.parameters = holder.parameters;
           if (body.isAsynchronous) {
             setter.asynchronous = true;
@@ skipping 46 matching lines @@
         AnalysisEngine.instance.logger.logError(
             buffer.toString(),
             new CaughtException(
                 new AnalysisException(buffer.toString()), null));
       }
     }
     return null;
   }
 
   @override
+  Object visitPartDirective(PartDirective node) {
+    _createElementAnnotations(node.metadata);
+    return super.visitPartDirective(node);
+  }
+
+  @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter =
           new ParameterElementImpl.forNode(parameterName);
       parameter.const3 = node.isConst;
       parameter.final2 = node.isFinal;
       parameter.parameterKind = node.kind;
       _setParameterVisibleRange(node, parameter);
       if (node.type == null) {
         parameter.hasImplicitType = true;
       }
       _currentHolder.addParameter(parameter);
       parameterName.staticElement = parameter;
     }
-    return super.visitSimpleFormalParameter(node);
+    super.visitSimpleFormalParameter(node);
+    (node.element as ElementImpl).metadata =
+        _createElementAnnotations(node.metadata);
+    return null;
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element = new LabelElementImpl(labelName, false, true);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
     return super.visitSwitchCase(node);
   }
 
   @override
   Object visitSwitchDefault(SwitchDefault node) {
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element = new LabelElementImpl(labelName, false, true);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
     return super.visitSwitchDefault(node);
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
     SimpleIdentifier parameterName = node.name;
     TypeParameterElementImpl typeParameter =
         new TypeParameterElementImpl.forNode(parameterName);
+    typeParameter.metadata = _createElementAnnotations(node.metadata);
     TypeParameterTypeImpl typeParameterType =
         new TypeParameterTypeImpl(typeParameter);
     typeParameter.type = typeParameterType;
     _currentHolder.addTypeParameter(typeParameter);
     parameterName.staticElement = typeParameter;
     return super.visitTypeParameter(node);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
@@ skipping 96 matching lines @@
         parameter.synthetic = true;
         parameter.parameterKind = ParameterKind.REQUIRED;
         setter.parameters = <ParameterElement>[parameter];
         _currentHolder.addAccessor(setter);
         element.setter = setter;
       }
     }
     return null;
   }
 
+  @override
+  Object visitVariableDeclarationList(VariableDeclarationList node) {
+    super.visitVariableDeclarationList(node);
+    AstNode parent = node.parent;
+    List<ElementAnnotation> elementAnnotations;
+    if (parent is FieldDeclaration) {
+      elementAnnotations = _createElementAnnotations(parent.metadata);
+    } else if (parent is TopLevelVariableDeclaration) {
+      elementAnnotations = _createElementAnnotations(parent.metadata);
+    } else {
+      // Local variable declaration
+      elementAnnotations = _createElementAnnotations(node.metadata);
+    }
+    for (VariableDeclaration variableDeclaration in node.variables) {
+      (variableDeclaration.element as ElementImpl).metadata =
+          elementAnnotations;
+    }
+    return null;
+  }
+
   /**
    * Build the table mapping field names to field elements for the fields defined in the current
    * class.
    *
    * @param fields the field elements defined in the current class
    */
   void _buildFieldMap(List<FieldElement> fields) {
     _fieldMap = new HashMap<String, FieldElement>();
     int count = fields.length;
     for (int i = 0; i < count; i++) {
@@ skipping 13 matching lines @@
     ConstructorElementImpl constructor =
         new ConstructorElementImpl.forNode(null);
     constructor.synthetic = true;
     constructor.returnType = definingClass.type;
     constructor.enclosingElement = definingClass;
     constructor.type = new FunctionTypeImpl(constructor);
     return <ConstructorElement>[constructor];
   }
 
   /**
+   * For each [Annotation] found in [annotations], create a new
+   * [ElementAnnotation] object and set the [Annotation] to point to it.
+   */
+  List<ElementAnnotation> _createElementAnnotations(
+      NodeList<Annotation> annotations) {
+    if (annotations.isEmpty) {
+      return ElementAnnotation.EMPTY_LIST;
+    }
+    return annotations.map((Annotation a) {
+      ElementAnnotationImpl elementAnnotation =
+          new ElementAnnotationImpl(compilationUnitElement);
+      a.elementAnnotation = elementAnnotation;
+      return elementAnnotation;
+    }).toList();
+  }
+
+  /**
    * Create the types associated with the given type parameters, setting the type of each type
    * parameter, and return an array of types corresponding to the given parameters.
    *
    * @param typeParameters the type parameters for which types are to be created
    * @return an array of types corresponding to the given parameters
    */
   List<DartType> _createTypeParameterTypes(
       List<TypeParameterElement> typeParameters) {
     int typeParameterCount = typeParameters.length;
     List<DartType> typeArguments = new List<DartType>(typeParameterCount);
@@ skipping 142 matching lines @@
     return null;
   }
 
   /**
    * Return the lexical identifiers associated with the given [identifiers].
    */
   static List<String> _getIdentifiers(NodeList<SimpleIdentifier> identifiers) {
     return identifiers.map((identifier) => identifier.name).toList();
   }
 }