Version 0.8.10.1

dart/pkg/analyzer/lib/src/generated/resolver.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.resolver;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 3252 matching lines @@
           }
         }
       }
     }
     return super.visitFieldFormalParameter(node);
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
-  Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) => null;
+  Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
+    Expression expression = node.function;
+    if (expression is FunctionExpression) {
+      FunctionExpression functionExpression = expression as FunctionExpression;
+      ExecutableElement functionElement = functionExpression.element;
+      ArgumentList argumentList = node.argumentList;
+      List<ParameterElement> parameters = resolveArgumentsToParameters(false, argumentList, functionElement);
+      if (parameters != null) {
+        argumentList.correspondingStaticParameters = parameters;
+      }
+    }
+    return null;
+  }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     setMetadata(node.element, node);
     return null;
   }
   Object visitImportDirective(ImportDirective node) {
     SimpleIdentifier prefixNode = node.prefix;
     if (prefixNode != null) {
       String prefixName = prefixNode.name;
       for (PrefixElement prefixElement in _definingLibrary.prefixes) {
         if (prefixElement.displayName == prefixName) {
@@ skipping 200 matching lines @@
     SimpleIdentifier identifier = node.identifier;
     Element prefixElement = prefix.staticElement;
     if (prefixElement is PrefixElement) {
       Element element = _resolver.nameScope.lookup(node, _definingLibrary);
       if (element == null && identifier.inSetterContext()) {
         element = _resolver.nameScope.lookup(new ElementResolver_SyntheticIdentifier("${node.name}="), _definingLibrary);
       }
       if (element == null) {
         if (identifier.inSetterContext()) {
           _resolver.reportError5(StaticWarningCode.UNDEFINED_SETTER, identifier, [identifier.name, prefixElement.name]);
+        } else if (node.parent is Annotation) {
+          Annotation annotation = node.parent as Annotation;
+          _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
+          return null;
         } else {
           _resolver.reportError5(StaticWarningCode.UNDEFINED_GETTER, identifier, [identifier.name, prefixElement.name]);
         }
         return null;
       }
       if (element is PropertyAccessorElement && identifier.inSetterContext()) {
         PropertyInducingElement variable = ((element as PropertyAccessorElement)).variable;
         if (variable != null) {
           PropertyAccessorElement setter = variable.setter;
           if (setter != null) {
@@ skipping 91 matching lines @@
     Element element = resolveSimpleIdentifier(node);
     ClassElement enclosingClass = _resolver.enclosingClass;
     if (isFactoryConstructorReturnType(node) && element != enclosingClass) {
       _resolver.reportError5(CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS, node, []);
     } else if (isConstructorReturnType(node) && element != enclosingClass) {
       _resolver.reportError5(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
       element = null;
     } else if (element == null || (element is PrefixElement && !isValidAsPrefix(node))) {
       if (isConstructorReturnType(node)) {
         _resolver.reportError5(CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME, node, []);
+      } else if (node.parent is Annotation) {
+        Annotation annotation = node.parent as Annotation;
+        _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       } else {
         _resolver.reportErrorProxyConditionalAnalysisError(_resolver.enclosingClass, StaticWarningCode.UNDEFINED_IDENTIFIER, node, [node.name]);
       }
     }
     node.staticElement = element;
     if (node.inSetterContext() && node.inGetterContext() && enclosingClass != null) {
       InterfaceType enclosingType = enclosingClass.type;
       AuxiliaryElements auxiliaryElements = new AuxiliaryElements(lookUpGetter(null, enclosingType, node.name), null);
       node.auxiliaryElements = auxiliaryElements;
     }
@@ skipping 3682 matching lines @@
    * the given expression with the given type. Generally speaking, it is appropriate if the given
    * type is more specific than the current type.
    *
    * @param expression the expression used to access the static element whose types might be
    *          promoted
    * @param potentialType the potential type of the elements
    */
   void promote(Expression expression, Type2 potentialType) {
     VariableElement element = getPromotionStaticElement(expression);
     if (element != null) {
+      if (((element as VariableElementImpl)).isPotentiallyMutatedInClosure) {
+        return;
+      }
       Type2 type = expression.staticType;
       if (type == null || type.isDynamic) {
         return;
       }
       if (potentialType == null || potentialType.isDynamic) {
         return;
       }
       if (!potentialType.isMoreSpecificThan(type)) {
         return;
       }
@@ skipping 87 matching lines @@
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
    *
    * If the variable <i>v</i> is accessed by a closure in <i>s<sub>1</sub></i> then the variable
    * <i>v</i> is not potentially mutated anywhere in the scope of <i>v</i>.
    */
   void clearTypePromotionsIfAccessedInScopeAndProtentiallyMutated(ASTNode target) {
     for (Element element in promoteManager.promotedElements) {
-      if (((element as VariableElementImpl)).isPotentiallyMutated) {
+      if (((element as VariableElementImpl)).isPotentiallyMutatedInScope) {
         if (isVariableAccessedInClosure(element, target)) {
           promoteManager.setType(element, null);
         }
       }
     }
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
@@ skipping 1637 matching lines @@
     SimpleIdentifier prefixedIdentifier = node.identifier;
     Element staticElement = prefixedIdentifier.staticElement;
     Type2 staticType = _dynamicType;
     if (staticElement is ClassElement) {
       if (isNotTypeLiteral(node)) {
         staticType = ((staticElement as ClassElement)).type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (staticElement is FunctionTypeAliasElement) {
-      staticType = ((staticElement as FunctionTypeAliasElement)).type;
+      if (isNotTypeLiteral(node)) {
+        staticType = ((staticElement as FunctionTypeAliasElement)).type;
+      } else {
+        staticType = _typeProvider.typeType;
+      }
     } else if (staticElement is MethodElement) {
       staticType = ((staticElement as MethodElement)).type;
     } else if (staticElement is PropertyAccessorElement) {
       staticType = getType(staticElement as PropertyAccessorElement, node.prefix.staticType);
     } else if (staticElement is ExecutableElement) {
       staticType = ((staticElement as ExecutableElement)).type;
     } else if (staticElement is TypeParameterElement) {
       staticType = ((staticElement as TypeParameterElement)).type;
     } else if (staticElement is VariableElement) {
       staticType = ((staticElement as VariableElement)).type;
@@ skipping 178 matching lines @@
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     Type2 staticType = _dynamicType;
     if (element is ClassElement) {
       if (isNotTypeLiteral(node)) {
         staticType = ((element as ClassElement)).type;
       } else {
         staticType = _typeProvider.typeType;
       }
     } else if (element is FunctionTypeAliasElement) {
-      staticType = ((element as FunctionTypeAliasElement)).type;
+      if (isNotTypeLiteral(node)) {
+        staticType = ((element as FunctionTypeAliasElement)).type;
+      } else {
+        staticType = _typeProvider.typeType;
+      }
     } else if (element is MethodElement) {
       staticType = ((element as MethodElement)).type;
     } else if (element is PropertyAccessorElement) {
       staticType = getType(element as PropertyAccessorElement, null);
     } else if (element is ExecutableElement) {
       staticType = ((element as ExecutableElement)).type;
     } else if (element is TypeParameterElement) {
       staticType = ((element as TypeParameterElement)).type;
     } else if (element is VariableElement) {
       VariableElement variable = element as VariableElement;
@@ skipping 2112 matching lines @@
 }
 /**
  * Instances of the class `VariableResolverVisitor` are used to resolve
  * [SimpleIdentifier]s to local variables and formal parameters.
  *
  * @coverage dart.engine.resolver
  */
 class VariableResolverVisitor extends ScopedVisitor {
 
   /**
+   * The method or function that we are currently visiting, or `null` if we are not inside a
+   * method or function.
+   */
+  ExecutableElement _enclosingFunction;
+
+  /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   VariableResolverVisitor(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider);
+  Object visitFunctionDeclaration(FunctionDeclaration node) {
+    ExecutableElement outerFunction = _enclosingFunction;
+    try {
+      _enclosingFunction = node.element;
+      return super.visitFunctionDeclaration(node);
+    } finally {
+      _enclosingFunction = outerFunction;
+    }
+  }
+  Object visitFunctionExpression(FunctionExpression node) {
+    if (node.parent is! FunctionDeclaration) {
+      ExecutableElement outerFunction = _enclosingFunction;
+      try {
+        _enclosingFunction = node.element;
+        return super.visitFunctionExpression(node);
+      } finally {
+        _enclosingFunction = outerFunction;
+      }
+    } else {
+      return super.visitFunctionExpression(node);
+    }
+  }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (node.staticElement != null) {
       return null;
     }
     ASTNode parent = node.parent;
     if (parent is PrefixedIdentifier && identical(((parent as PrefixedIdentifier)).identifier, node)) {
       return null;
     }
     if (parent is PropertyAccess && identical(((parent as PropertyAccess)).propertyName, node)) {
       return null;
     }
     if (parent is MethodInvocation && identical(((parent as MethodInvocation)).methodName, node)) {
       return null;
     }
     if (parent is ConstructorName) {
       return null;
     }
     if (parent is Label) {
       return null;
     }
     Element element = nameScope.lookup(node, definingLibrary);
     if (element is! VariableElement) {
       return null;
     }
     ElementKind kind = element.kind;
     if (identical(kind, ElementKind.LOCAL_VARIABLE)) {
       node.staticElement = element;
       if (node.inSetterContext()) {
-        ((element as LocalVariableElementImpl)).markPotentiallyMutated();
+        LocalVariableElementImpl variableImpl = element as LocalVariableElementImpl;
+        variableImpl.markPotentiallyMutatedInScope();
+        if (element.enclosingElement != _enclosingFunction) {
+          variableImpl.markPotentiallyMutatedInClosure();
+        }
       }
     } else if (identical(kind, ElementKind.PARAMETER)) {
       node.staticElement = element;
       if (node.inSetterContext()) {
-        ((element as ParameterElementImpl)).markPotentiallyMutated();
+        ParameterElementImpl parameterImpl = element as ParameterElementImpl;
+        parameterImpl.markPotentiallyMutatedInScope();
+        if (_enclosingFunction != null && (element.enclosingElement != _enclosingFunction)) {
+          parameterImpl.markPotentiallyMutatedInClosure();
+        }
       }
     }
     return null;
   }
 }
 /**
  * Instances of the class `ClassScope` implement the scope defined by a class.
  *
  * @coverage dart.engine.resolver
  */
@@ skipping 67 matching lines @@
   Set<String> _hiddenNames = new Set<String>();
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    */
   EnclosedScope(Scope enclosingScope) {
     this.enclosingScope = enclosingScope;
   }
-  LibraryElement get definingLibrary => enclosingScope.definingLibrary;
   AnalysisErrorListener get errorListener => enclosingScope.errorListener;
 
   /**
    * Hides the name of the given element in this scope. If there is already an element with the
    * given name defined in an outer scope, then it will become unavailable.
    *
    * @param element the element to be hidden in this scope
    */
   void hide(Element element) {
     if (element != null) {
       String name = element.name;
       if (name != null && !name.isEmpty) {
         javaSetAdd(_hiddenNames, name);
       }
     }
   }
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element element = localLookup(name, referencingLibrary);
     if (element != null) {
       return element;
     }
     if (_hiddenNames.contains(name)) {
-      errorListener.onError(new AnalysisError.con2(source, identifier.offset, identifier.length, CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION, []));
+      errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION, []));
     }
     return enclosingScope.lookup3(identifier, name, referencingLibrary);
   }
 }
 /**
  * Instances of the class `FunctionScope` implement the scope defined by a function.
  *
  * @coverage dart.engine.resolver
  */
 class FunctionScope extends EnclosedScope {
@@ skipping 197 matching lines @@
   LibraryImportScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
     this._errorListener = errorListener;
     createImportedNamespaces(definingLibrary);
   }
   void define(Element element) {
     if (!Scope.isPrivateName(element.displayName)) {
       super.define(element);
     }
   }
-  LibraryElement get definingLibrary => _definingLibrary;
   AnalysisErrorListener get errorListener => _errorListener;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element foundElement = localLookup(name, referencingLibrary);
     if (foundElement != null) {
       return foundElement;
     }
     for (Namespace nameSpace in _importedNamespaces) {
       Element element = nameSpace.get(name);
       if (element != null) {
         if (foundElement == null) {
           foundElement = element;
         } else if (foundElement != element) {
           foundElement = MultiplyDefinedElementImpl.fromElements(_definingLibrary.context, foundElement, element);
         }
       }
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       foundElement = removeSdkElements(identifier, name, foundElement as MultiplyDefinedElementImpl);
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       String foundEltName = foundElement.displayName;
       List<Element> conflictingMembers = ((foundElement as MultiplyDefinedElementImpl)).conflictingElements;
       String libName1 = getLibraryName(conflictingMembers[0], "");
       String libName2 = getLibraryName(conflictingMembers[1], "");
-      _errorListener.onError(new AnalysisError.con2(getSource2(identifier), identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
+      _errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
       return foundElement;
     }
     if (foundElement != null) {
       defineWithoutChecking2(name, foundElement);
     }
     return foundElement;
   }
 
   /**
    * Create all of the namespaces associated with the libraries imported into this library. The
@@ skipping 21 matching lines @@
       return def;
     }
     LibraryElement library = element.library;
     if (library == null) {
       return def;
     }
     return library.definingCompilationUnit.displayName;
   }
 
   /**
-   * Return the source that contains the given identifier, or the source associated with this scope
-   * if the source containing the identifier could not be determined.
-   *
-   * @param identifier the identifier whose source is to be returned
-   * @return the source that contains the given identifier
-   */
-  Source getSource2(Identifier identifier) {
-    CompilationUnit unit = identifier.getAncestor(CompilationUnit);
-    if (unit != null) {
-      CompilationUnitElement element = unit.element;
-      if (element != null) {
-        Source source = element.source;
-        if (source != null) {
-          return source;
-        }
-      }
-    }
-    return this.source;
-  }
-
-  /**
    * Given a collection of elements that a single name could all be mapped to, remove from the list
    * all of the names defined in the SDK. Return the element(s) that remain.
    *
    * @param identifier the identifier node to lookup element for, used to report correct kind of a
    *          problem and associate problem with
    * @param name the name associated with the element
    * @param foundElement the element encapsulating the collection of elements
    * @return all of the elements that are not defined in the SDK
    */
   Element removeSdkElements(Identifier identifier, String name, MultiplyDefinedElementImpl foundElement) {
     List<Element> conflictingMembers = foundElement.conflictingElements;
     int length = conflictingMembers.length;
     int to = 0;
     Element sdkElement = null;
     for (Element member in conflictingMembers) {
       if (member.library.isInSdk) {
         sdkElement = member;
       } else {
         conflictingMembers[to++] = member;
       }
     }
     if (sdkElement != null && to > 0) {
       String sdkLibName = getLibraryName(sdkElement, "");
       String otherLibName = getLibraryName(conflictingMembers[0], "");
-      _errorListener.onError(new AnalysisError.con2(getSource2(identifier), identifier.offset, identifier.length, StaticWarningCode.CONFLICTING_DART_IMPORT, [name, sdkLibName, otherLibName]));
+      _errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.CONFLICTING_DART_IMPORT, [name, sdkLibName, otherLibName]));
     }
     if (to == length) {
       return foundElement;
     } else if (to == 1) {
       return conflictingMembers[0];
     } else if (to == 0) {
       AnalysisEngine.instance.logger.logInformation("Multiply defined SDK element: ${foundElement}");
       return foundElement;
     }
     List<Element> remaining = new List<Element>(to);
@@ skipping 20 matching lines @@
   }
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PrefixElement) {
       int offset = duplicate.nameOffset;
       if (duplicate is PropertyAccessorElement) {
         PropertyAccessorElement accessor = duplicate as PropertyAccessorElement;
         if (accessor.isSynthetic) {
           offset = accessor.variable.nameOffset;
         }
       }
-      return new AnalysisError.con2(source, offset, duplicate.displayName.length, CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER, [existing.displayName]);
+      return new AnalysisError.con2(duplicate.source, offset, duplicate.displayName.length, CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER, [existing.displayName]);
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
 
   /**
    * Add to this scope all of the public top-level names that are defined in the given compilation
    * unit.
    *
    * @param compilationUnit the compilation unit defining the top-level names to be added to this
    *          scope
@@ skipping 382 matching lines @@
    * Add the given element to this scope without checking for duplication or hiding.
    *
    * @param name the name of the element to be added
    * @param element the element to be added to this scope
    */
   void defineWithoutChecking2(String name, Element element) {
     _definedNames[name] = element;
   }
 
   /**
-   * Return the element representing the library in which this scope is enclosed.
-   *
-   * @return the element representing the library in which this scope is enclosed
-   */
-  LibraryElement get definingLibrary;
-
-  /**
    * Return the error code to be used when reporting that a name being defined locally conflicts
    * with another element of the same name in the local scope.
    *
    * @param existing the first element to be declared with the conflicting name
    * @param duplicate another element declared with the conflicting name
    * @return the error code used to report duplicate names within a scope
    */
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     Source source = duplicate.source;
-    if (source == null) {
-      source = this.source;
-    }
     return new AnalysisError.con2(source, duplicate.nameOffset, duplicate.displayName.length, CompileTimeErrorCode.DUPLICATE_DEFINITION, [existing.displayName]);
   }
 
   /**
    * Return the listener that is to be informed when an error is encountered.
    *
    * @return the listener that is to be informed when an error is encountered
    */
   AnalysisErrorListener get errorListener;
 
   /**
-   * Return the source object representing the compilation unit with which errors related to this
-   * scope should be associated.
+   * Return the source that contains the given identifier, or the source associated with this scope
+   * if the source containing the identifier could not be determined.
    *
-   * @return the source object with which errors should be associated
+   * @param identifier the identifier whose source is to be returned
+   * @return the source that contains the given identifier
    */
-  Source get source => definingLibrary.definingCompilationUnit.source;
+  Source getSource(ASTNode node) {
+    CompilationUnit unit = node.getAncestor(CompilationUnit);
+    if (unit != null) {
+      CompilationUnitElement unitElement = unit.element;
+      if (unitElement != null) {
+        return unitElement.source;
+      }
+    }
+    return null;
+  }
 
   /**
    * Return the element with which the given name is associated, or `null` if the name is not
    * defined within this scope. This method only returns elements that are directly defined within
    * this scope, not elements that are defined in an enclosing scope.
    *
    * @param name the name associated with the element to be returned
    * @param referencingLibrary the library that contains the reference to the name, used to
    *          implement library-level privacy
    * @return the element with which the given name is associated
@@ skipping 1004 matching lines @@
     }
     checkForAllReturnStatementErrorCodes(node);
     return super.visitReturnStatement(node);
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     checkForConstFormalParameter(node);
     checkForPrivateOptionalParameter(node);
     return super.visitSimpleFormalParameter(node);
   }
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    checkForReferenceToDeclaredVariableInInitializer(node);
     checkForImplicitThisReferenceInInitializer(node);
     if (!isUnqualifiedReferenceToNonLocalStaticMemberAllowed(node)) {
       checkForUnqualifiedReferenceToNonLocalStaticMember(node);
     }
     return super.visitSimpleIdentifier(node);
   }
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     _isInConstructorInitializer = true;
     try {
       return super.visitSuperConstructorInvocation(node);
@@ skipping 2867 matching lines @@
       return false;
     }
     if (redirectedConstructor.isConst) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR, redirectedConstructorNode, []);
     return true;
   }
 
   /**
-   * This checks if the passed identifier is banned because it is part of the variable declaration
-   * with the same name.
-   *
-   * @param node the identifier to evaluate
-   * @return `true` if and only if an error code is generated on the passed node
-   * @see CompileTimeErrorCode#REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER
-   */
-  bool checkForReferenceToDeclaredVariableInInitializer(SimpleIdentifier node) {
-    ASTNode parent = node.parent;
-    if (parent is PrefixedIdentifier) {
-      PrefixedIdentifier prefixedIdentifier = parent as PrefixedIdentifier;
-      if (identical(prefixedIdentifier.identifier, node)) {
-        return false;
-      }
-    }
-    if (parent is PropertyAccess) {
-      PropertyAccess propertyAccess = parent as PropertyAccess;
-      if (identical(propertyAccess.propertyName, node)) {
-        return false;
-      }
-    }
-    if (parent is MethodInvocation) {
-      MethodInvocation methodInvocation = parent as MethodInvocation;
-      if (methodInvocation.target != null && identical(methodInvocation.methodName, node)) {
-        return false;
-      }
-    }
-    if (parent is ConstructorName) {
-      ConstructorName constructorName = parent as ConstructorName;
-      if (identical(constructorName.name, node)) {
-        return false;
-      }
-    }
-    if (parent is Label) {
-      Label label = parent as Label;
-      if (identical(label.label, node)) {
-        return false;
-      }
-    }
-    String name = node.name;
-    if (!_namesForReferenceToDeclaredVariableInInitializer.contains(name)) {
-      return false;
-    }
-    _errorReporter.reportError2(CompileTimeErrorCode.REFERENCE_TO_DECLARED_VARIABLE_IN_INITIALIZER, node, [name]);
-    return true;
-  }
-
-  /**
    * This checks that the rethrow is inside of a catch clause.
    *
    * @param node the rethrow expression to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RETHROW_OUTSIDE_CATCH
    */
   bool checkForRethrowOutsideCatch(RethrowExpression node) {
     if (!_isInCatchClause) {
       _errorReporter.reportError2(CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH, node, []);
       return true;
@@ skipping 631 matching lines @@
     ASTNode parent = node.parent;
     if (parent is ConstructorName || parent is MethodInvocation || parent is PropertyAccess || parent is SuperConstructorInvocation) {
       return true;
     }
     if (parent is PrefixedIdentifier && identical(((parent as PrefixedIdentifier)).identifier, node)) {
       return true;
     }
     if (parent is Annotation && identical(((parent as Annotation)).constructorName, node)) {
       return true;
     }
+    if (parent is CommentReference) {
+      CommentReference commentReference = parent as CommentReference;
+      if (commentReference.newKeyword != null) {
+        return true;
+      }
+    }
     return false;
   }
 
   /**
    * Return `true` iff the passed [ClassElement] has a concrete implementation of the
    * passed accessor name in the superclass chain.
    */
   bool memberHasConcreteAccessorImplementationInSuperclassChain(ClassElement classElement, String accessorName, List<ClassElement> superclassChain) {
     if (superclassChain.contains(classElement)) {
       return false;
@@ skipping 200 matching lines @@
   ResolverErrorCode.con2(String name, int ordinal, ErrorType type, String message, String correction) : super(name, ordinal) {
     this._type = type;
     this._message = message;
     this.correction9 = correction;
   }
   String get correction => correction9;
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
 }