New analyzer_experimental snapshot.

pkg/analyzer_experimental/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;
 import 'utilities_dart.dart';
 import 'ast.dart';
 import 'parser.dart' show Parser, ParserErrorCode;
 import 'sdk.dart' show DartSdk, SdkLibrary;
 import 'element.dart';
 import 'html.dart' as ht;
 import 'engine.dart';
 import 'constant.dart';
 /**
- * Instances of the class {@code CompilationUnitBuilder} build an element model for a single
+ * Instances of the class `CompilationUnitBuilder` build an element model for a single
  * compilation unit.
  * @coverage dart.engine.resolver
  */
 class CompilationUnitBuilder {
 
   /**
    * Build the compilation unit element for the given source.
    * @param source the source describing the compilation unit
    * @param unit the AST structure representing the compilation unit
    * @return the compilation unit element that was built
@@ skipping 11 matching lines @@
     element.functions = holder.functions;
     element.source = source2;
     element.typeAliases = holder.typeAliases;
     element.types = holder.types;
     element.topLevelVariables = holder.topLevelVariables;
     unit.element = element;
     return element;
   }
 }
 /**
- * Instances of the class {@code ElementBuilder} traverse an AST structure and build the element
+ * Instances of the class `ElementBuilder` traverse an AST structure and build the element
  * model representing the AST structure.
  * @coverage dart.engine.resolver
  */
 class ElementBuilder extends RecursiveASTVisitor<Object> {
 
   /**
    * 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;
 
   /**
    * A flag indicating whether a variable declaration is within the body of a method or function.
    */
   bool _inFunction = false;
 
   /**
    * A flag indicating whether the class currently being visited can be used as a mixin.
    */
   bool _isValidMixin = false;
 
   /**
+   * A collection holding the function types defined in a class that need to have their type
+   * arguments set to the types of the type parameters for the class, or `null` if we are not
+   * currently processing nodes within a class.
+   */
+  List<FunctionTypeImpl> _functionTypesToFix = null;
+
+  /**
    * 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) {
     _currentHolder = initialHolder;
   }
   Object visitBlock(Block node) {
     bool wasInField = _inFieldContext;
     _inFieldContext = false;
     try {
@@ skipping 14 matching lines @@
         LocalVariableElementImpl stackTrace = new LocalVariableElementImpl(stackTraceParameter);
         _currentHolder.addLocalVariable(stackTrace);
         stackTraceParameter.element = stackTrace;
       }
     }
     return super.visitCatchClause(node);
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     ElementHolder holder = new ElementHolder();
     _isValidMixin = true;
+    _functionTypesToFix = new List<FunctionTypeImpl>();
     visitChildren(holder, node);
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl(className);
     List<TypeVariableElement> typeVariables = holder.typeVariables;
+    List<Type2> typeArguments = createTypeVariableTypes(typeVariables);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
-    interfaceType.typeArguments = createTypeVariableTypes(typeVariables);
+    interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     List<ConstructorElement> constructors = holder.constructors;
     if (constructors.length == 0) {
       constructors = createDefaultConstructors(interfaceType);
     }
     element.abstract = node.abstractKeyword != null;
     element.accessors = holder.accessors;
     element.constructors = constructors;
     element.fields = holder.fields;
     element.methods = holder.methods;
     element.typeVariables = typeVariables;
     element.validMixin = _isValidMixin;
+    for (FunctionTypeImpl functionType in _functionTypesToFix) {
+      functionType.typeArguments = typeArguments;
+    }
+    _functionTypesToFix = null;
     _currentHolder.addType(element);
     className.element = element;
+    holder.validate();
     return null;
   }
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ElementHolder holder = new ElementHolder();
+    _functionTypesToFix = new List<FunctionTypeImpl>();
     visitChildren(holder, node);
     SimpleIdentifier className = node.name;
     ClassElementImpl element = new ClassElementImpl(className);
     element.abstract = node.abstractKeyword != null;
     element.typedef = true;
     List<TypeVariableElement> typeVariables = holder.typeVariables;
     element.typeVariables = typeVariables;
+    List<Type2> typeArguments = createTypeVariableTypes(typeVariables);
     InterfaceTypeImpl interfaceType = new InterfaceTypeImpl.con1(element);
-    interfaceType.typeArguments = createTypeVariableTypes(typeVariables);
+    interfaceType.typeArguments = typeArguments;
     element.type = interfaceType;
     element.constructors = createDefaultConstructors(interfaceType);
+    for (FunctionTypeImpl functionType in _functionTypesToFix) {
+      functionType.typeArguments = typeArguments;
+    }
+    _functionTypesToFix = null;
     _currentHolder.addType(element);
     className.element = element;
+    holder.validate();
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     _isValidMixin = false;
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       visitChildren(holder, node);
     } finally {
@@ skipping 12 matching lines @@
     _currentHolder.addConstructor(element);
     node.element = element;
     if (constructorName == null) {
       Identifier returnType = node.returnType;
       if (returnType != null) {
         element.nameOffset = returnType.offset;
       }
     } else {
       constructorName.element = element;
     }
+    holder.validate();
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     SimpleIdentifier variableName = node.identifier;
     sc.Token keyword = node.keyword;
     LocalVariableElementImpl element = new LocalVariableElementImpl(variableName);
     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 = matches(keyword, sc.Keyword.CONST);
     element.final2 = matches(keyword, sc.Keyword.FINAL);
     _currentHolder.addLocalVariable(element);
     variableName.element = element;
     return super.visitDeclaredIdentifier(node);
   }
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     ElementHolder holder = new ElementHolder();
     visit(holder, node.defaultValue);
     FunctionElementImpl initializer = new FunctionElementImpl();
     initializer.functions = holder.functions;
     initializer.labels = holder.labels;
     initializer.localVariables = holder.localVariables;
     initializer.parameters = holder.parameters;
     SimpleIdentifier parameterName = node.parameter.identifier;
     ParameterElementImpl parameter;
-    if (node.isConst()) {
-      parameter = new ConstParameterElementImpl(parameterName);
-      parameter.const3 = true;
-    } else if (node.parameter is FieldFormalParameter) {
-      parameter = new FieldFormalParameterElementImpl(parameterName);
+    if (node.parameter is FieldFormalParameter) {
+      parameter = new DefaultFieldFormalParameterElementImpl(parameterName);
     } else {
-      parameter = new ParameterElementImpl(parameterName);
+      parameter = new DefaultParameterElementImpl(parameterName);
     }
+    parameter.const3 = node.isConst();
     parameter.final2 = node.isFinal();
     parameter.initializer = initializer;
     parameter.parameterKind = node.kind;
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       parameter.setDefaultValueRange(defaultValue.offset, defaultValue.length);
     }
     FunctionBody body = getFunctionBody(node);
     if (body != null) {
       parameter.setVisibleRange(body.offset, body.length);
     }
     _currentHolder.addParameter(parameter);
     parameterName.element = parameter;
     node.parameter.accept(this);
+    holder.validate();
     return null;
   }
   Object visitFieldDeclaration(FieldDeclaration node) {
     bool wasInField = _inFieldContext;
     _inFieldContext = true;
     try {
       node.visitChildren(this);
     } finally {
       _inFieldContext = wasInField;
     }
@@ skipping 23 matching lines @@
         _inFunction = wasInFunction;
       }
       sc.Token property = node.propertyKeyword;
       if (property == null) {
         SimpleIdentifier functionName = node.name;
         FunctionElementImpl element = new FunctionElementImpl.con1(functionName);
         element.functions = holder.functions;
         element.labels = holder.labels;
         element.localVariables = holder.localVariables;
         element.parameters = holder.parameters;
-        FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
-        element.type = type;
         _currentHolder.addFunction(element);
         expression.element = element;
         functionName.element = element;
       } else {
         SimpleIdentifier propertyNameNode = node.name;
         if (propertyNameNode == null) {
           return null;
         }
         String propertyName = propertyNameNode.name;
         FieldElementImpl field = _currentHolder.getField(propertyName) as FieldElementImpl;
@@ skipping 22 matching lines @@
           setter.parameters = holder.parameters;
           setter.variable = field;
           setter.setter = true;
           setter.static = true;
           field.setter = setter;
           field.final2 = false;
           _currentHolder.addAccessor(setter);
           propertyNameNode.element = setter;
         }
       }
+      holder.validate();
     }
     return null;
   }
   Object visitFunctionExpression(FunctionExpression node) {
     ElementHolder holder = new ElementHolder();
     bool wasInFunction = _inFunction;
     _inFunction = true;
     try {
       visitChildren(holder, node);
     } finally {
       _inFunction = wasInFunction;
     }
     FunctionElementImpl element = new FunctionElementImpl.con2(node.beginToken.offset);
     element.functions = holder.functions;
     element.labels = holder.labels;
     element.localVariables = holder.localVariables;
     element.parameters = holder.parameters;
     if (_inFunction) {
       Block enclosingBlock = node.getAncestor(Block);
       if (enclosingBlock != null) {
         int functionEnd = node.offset + node.length;
         int blockEnd = enclosingBlock.offset + enclosingBlock.length;
         element.setVisibleRange(functionEnd, blockEnd - functionEnd - 1);
       }
     }
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
+    if (_functionTypesToFix != null) {
+      _functionTypesToFix.add(type);
+    }
     element.type = type;
     _currentHolder.addFunction(element);
     node.element = element;
+    holder.validate();
     return null;
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     ElementHolder holder = new ElementHolder();
     visitChildren(holder, node);
     SimpleIdentifier aliasName = node.name;
     List<ParameterElement> parameters = holder.parameters;
     List<TypeVariableElement> typeVariables = holder.typeVariables;
     FunctionTypeAliasElementImpl element = new FunctionTypeAliasElementImpl(aliasName);
     element.parameters = parameters;
     element.typeVariables = typeVariables;
     FunctionTypeImpl type = new FunctionTypeImpl.con2(element);
     type.typeArguments = createTypeVariableTypes(typeVariables);
     element.type = type;
     _currentHolder.addTypeAlias(element);
     aliasName.element = element;
+    holder.validate();
     return null;
   }
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter = new ParameterElementImpl(parameterName);
       parameter.parameterKind = node.kind;
       _currentHolder.addParameter(parameter);
       parameterName.element = parameter;
     }
     ElementHolder holder = new ElementHolder();
     visitChildren(holder, node);
     ((node.element as ParameterElementImpl)).parameters = holder.parameters;
+    holder.validate();
     return null;
   }
   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.element = element;
     }
@@ skipping 56 matching lines @@
         setter.variable = field;
         setter.abstract = node.body is EmptyFunctionBody && !matches(node.externalKeyword, sc.Keyword.EXTERNAL);
         setter.setter = true;
         setter.static = isStatic;
         field.setter = setter;
         field.final2 = false;
         _currentHolder.addAccessor(setter);
         propertyNameNode.element = setter;
       }
     }
+    holder.validate();
     return null;
   }
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       SimpleIdentifier parameterName = node.identifier;
       ParameterElementImpl parameter = new ParameterElementImpl(parameterName);
       parameter.const3 = node.isConst();
       parameter.final2 = node.isFinal();
       parameter.parameterKind = node.kind;
       _currentHolder.addParameter(parameter);
@@ skipping 86 matching lines @@
         visit(holder, node.initializer);
       } finally {
         _inFieldContext = wasInFieldContext;
       }
       FunctionElementImpl initializer = new FunctionElementImpl();
       initializer.functions = holder.functions;
       initializer.labels = holder.labels;
       initializer.localVariables = holder.localVariables;
       initializer.synthetic = true;
       element.initializer = initializer;
+      holder.validate();
     }
     if (element is PropertyInducingElementImpl) {
       PropertyInducingElementImpl variable = element as PropertyInducingElementImpl;
       if (_inFieldContext) {
         ((variable as FieldElementImpl)).static = matches(((node.parent.parent as FieldDeclaration)).keyword, sc.Keyword.STATIC);
       }
       PropertyAccessorElementImpl getter = new PropertyAccessorElementImpl.con2(variable);
       getter.getter = true;
       getter.static = variable.isStatic();
       _currentHolder.addAccessor(getter);
       variable.getter = getter;
       if (!isFinal) {
         PropertyAccessorElementImpl setter = new PropertyAccessorElementImpl.con2(variable);
         setter.setter = true;
         setter.static = variable.isStatic();
         _currentHolder.addAccessor(setter);
         variable.setter = setter;
       }
     }
     return null;
   }
 
   /**
-   * Creates the {@link ConstructorElement}s array with the single default constructor element.
+   * Creates the [ConstructorElement]s array with the single default constructor element.
    * @param interfaceType the interface type for which to create a default constructor
-   * @return the {@link ConstructorElement}s array with the single default constructor element
+   * @return the [ConstructorElement]s array with the single default constructor element
    */
   List<ConstructorElement> createDefaultConstructors(InterfaceTypeImpl interfaceType) {
     ConstructorElementImpl constructor = new ConstructorElementImpl(null);
     constructor.synthetic = true;
+    constructor.returnType = interfaceType;
     FunctionTypeImpl type = new FunctionTypeImpl.con1(constructor);
-    type.returnType = interfaceType;
+    _functionTypesToFix.add(type);
     constructor.type = type;
     return <ConstructorElement> [constructor];
   }
+
+  /**
+   * Create the types associated with the given type variables, setting the type of each type
+   * variable, and return an array of types corresponding to the given variables.
+   * @param typeVariables the type variables for which types are to be created
+   * @return
+   */
   List<Type2> createTypeVariableTypes(List<TypeVariableElement> typeVariables) {
     int typeVariableCount = typeVariables.length;
     List<Type2> typeArguments = new List<Type2>(typeVariableCount);
     for (int i = 0; i < typeVariableCount; i++) {
       TypeVariableElementImpl typeVariable = typeVariables[i] as TypeVariableElementImpl;
       TypeVariableTypeImpl typeArgument = new TypeVariableTypeImpl(typeVariable);
       typeVariable.type = typeArgument;
       typeArguments[i] = typeArgument;
     }
     return typeArguments;
   }
 
   /**
-   * Return the body of the function that contains the given parameter, or {@code null} if no
+   * Return the body of the function that contains the given parameter, or `null` if no
    * function body could be found.
    * @param node the parameter contained in the function whose body is to be returned
    * @return the body of the function that contains the given parameter
    */
   FunctionBody getFunctionBody(FormalParameter node) {
     ASTNode parent = node.parent;
     while (parent != null) {
       if (parent is FunctionExpression) {
         return ((parent as FunctionExpression)).body;
       } else if (parent is MethodDeclaration) {
         return ((parent as MethodDeclaration)).body;
       }
       parent = parent.parent;
     }
     return null;
   }
 
   /**
-   * Return {@code true} if the given token is a token for the given keyword.
+   * Return `true` if the given token is a token for the given keyword.
    * @param token the token being tested
    * @param keyword the keyword being tested for
-   * @return {@code true} if the given token is a token for the given keyword
+   * @return `true` if the given token is a token for the given keyword
    */
   bool matches(sc.Token token, sc.Keyword keyword2) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical(((token as sc.KeywordToken)).keyword, keyword2);
 
   /**
    * Make the given holder be the current holder while visiting the given node.
    * @param holder the holder that will gather elements that are built while visiting the children
    * @param node the node to be visited
    */
   void visit(ElementHolder holder, ASTNode node) {
     if (node != null) {
@@ skipping 18 matching lines @@
       _currentHolder = holder;
       try {
         node.visitChildren(this);
       } finally {
         _currentHolder = previousHolder;
       }
     }
   }
 }
 /**
- * Instances of the class {@code ElementHolder} hold on to elements created while traversing an AST
+ * Instances of the class `ElementHolder` hold on to elements created while traversing an AST
  * structure so that they can be accessed when creating their enclosing element.
  * @coverage dart.engine.resolver
  */
 class ElementHolder {
-  List<PropertyAccessorElement> _accessors = new List<PropertyAccessorElement>();
-  List<ConstructorElement> _constructors = new List<ConstructorElement>();
-  List<FieldElement> _fields = new List<FieldElement>();
-  List<FunctionElement> _functions = new List<FunctionElement>();
-  List<LabelElement> _labels = new List<LabelElement>();
-  List<VariableElement> _localVariables = new List<VariableElement>();
-  List<MethodElement> _methods = new List<MethodElement>();
-  List<FunctionTypeAliasElement> _typeAliases = new List<FunctionTypeAliasElement>();
-  List<ParameterElement> _parameters = new List<ParameterElement>();
-  List<VariableElement> _topLevelVariables = new List<VariableElement>();
-  List<ClassElement> _types = new List<ClassElement>();
-  List<TypeVariableElement> _typeVariables = new List<TypeVariableElement>();
+  List<PropertyAccessorElement> _accessors;
+  List<ConstructorElement> _constructors;
+  List<FieldElement> _fields;
+  List<FunctionElement> _functions;
+  List<LabelElement> _labels;
+  List<VariableElement> _localVariables;
+  List<MethodElement> _methods;
+  List<ParameterElement> _parameters;
+  List<VariableElement> _topLevelVariables;
+  List<ClassElement> _types;
+  List<FunctionTypeAliasElement> _typeAliases;
+  List<TypeVariableElement> _typeVariables;
   void addAccessor(PropertyAccessorElement element) {
+    if (_accessors == null) {
+      _accessors = new List<PropertyAccessorElement>();
+    }
     _accessors.add(element);
   }
   void addConstructor(ConstructorElement element) {
+    if (_constructors == null) {
+      _constructors = new List<ConstructorElement>();
+    }
     _constructors.add(element);
   }
   void addField(FieldElement element) {
+    if (_fields == null) {
+      _fields = new List<FieldElement>();
+    }
     _fields.add(element);
   }
   void addFunction(FunctionElement element) {
+    if (_functions == null) {
+      _functions = new List<FunctionElement>();
+    }
     _functions.add(element);
   }
   void addLabel(LabelElement element) {
+    if (_labels == null) {
+      _labels = new List<LabelElement>();
+    }
     _labels.add(element);
   }
   void addLocalVariable(LocalVariableElement element) {
+    if (_localVariables == null) {
+      _localVariables = new List<VariableElement>();
+    }
     _localVariables.add(element);
   }
   void addMethod(MethodElement element) {
+    if (_methods == null) {
+      _methods = new List<MethodElement>();
+    }
     _methods.add(element);
   }
   void addParameter(ParameterElement element) {
+    if (_parameters == null) {
+      _parameters = new List<ParameterElement>();
+    }
     _parameters.add(element);
   }
   void addTopLevelVariable(TopLevelVariableElement element) {
+    if (_topLevelVariables == null) {
+      _topLevelVariables = new List<VariableElement>();
+    }
     _topLevelVariables.add(element);
   }
   void addType(ClassElement element) {
+    if (_types == null) {
+      _types = new List<ClassElement>();
+    }
     _types.add(element);
   }
   void addTypeAlias(FunctionTypeAliasElement element) {
+    if (_typeAliases == null) {
+      _typeAliases = new List<FunctionTypeAliasElement>();
+    }
     _typeAliases.add(element);
   }
   void addTypeVariable(TypeVariableElement element) {
+    if (_typeVariables == null) {
+      _typeVariables = new List<TypeVariableElement>();
+    }
     _typeVariables.add(element);
   }
   List<PropertyAccessorElement> get accessors {
-    if (_accessors.isEmpty) {
+    if (_accessors == null) {
       return PropertyAccessorElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_accessors);
+    List<PropertyAccessorElement> result = new List.from(_accessors);
+    _accessors = null;
+    return result;
   }
   List<ConstructorElement> get constructors {
-    if (_constructors.isEmpty) {
+    if (_constructors == null) {
       return ConstructorElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_constructors);
+    List<ConstructorElement> result = new List.from(_constructors);
+    _constructors = null;
+    return result;
   }
   FieldElement getField(String fieldName) {
+    if (_fields == null) {
+      return null;
+    }
     for (FieldElement field in _fields) {
       if (field.name == fieldName) {
         return field;
       }
     }
     return null;
   }
   List<FieldElement> get fields {
-    if (_fields.isEmpty) {
+    if (_fields == null) {
       return FieldElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_fields);
+    List<FieldElement> result = new List.from(_fields);
+    _fields = null;
+    return result;
   }
   List<FunctionElement> get functions {
-    if (_functions.isEmpty) {
+    if (_functions == null) {
       return FunctionElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_functions);
+    List<FunctionElement> result = new List.from(_functions);
+    _functions = null;
+    return result;
   }
   List<LabelElement> get labels {
-    if (_labels.isEmpty) {
+    if (_labels == null) {
       return LabelElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_labels);
+    List<LabelElement> result = new List.from(_labels);
+    _labels = null;
+    return result;
   }
   List<LocalVariableElement> get localVariables {
-    if (_localVariables.isEmpty) {
+    if (_localVariables == null) {
       return LocalVariableElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_localVariables);
+    List<LocalVariableElement> result = new List.from(_localVariables);
+    _localVariables = null;
+    return result;
   }
   List<MethodElement> get methods {
-    if (_methods.isEmpty) {
+    if (_methods == null) {
       return MethodElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_methods);
+    List<MethodElement> result = new List.from(_methods);
+    _methods = null;
+    return result;
   }
   List<ParameterElement> get parameters {
-    if (_parameters.isEmpty) {
+    if (_parameters == null) {
       return ParameterElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_parameters);
+    List<ParameterElement> result = new List.from(_parameters);
+    _parameters = null;
+    return result;
   }
   List<TopLevelVariableElement> get topLevelVariables {
-    if (_topLevelVariables.isEmpty) {
+    if (_topLevelVariables == null) {
       return TopLevelVariableElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_topLevelVariables);
+    List<TopLevelVariableElement> result = new List.from(_topLevelVariables);
+    _topLevelVariables = null;
+    return result;
   }
   List<FunctionTypeAliasElement> get typeAliases {
-    if (_typeAliases.isEmpty) {
+    if (_typeAliases == null) {
       return FunctionTypeAliasElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_typeAliases);
+    List<FunctionTypeAliasElement> result = new List.from(_typeAliases);
+    _typeAliases = null;
+    return result;
   }
   List<ClassElement> get types {
-    if (_types.isEmpty) {
+    if (_types == null) {
       return ClassElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_types);
+    List<ClassElement> result = new List.from(_types);
+    _types = null;
+    return result;
   }
   List<TypeVariableElement> get typeVariables {
-    if (_typeVariables.isEmpty) {
+    if (_typeVariables == null) {
       return TypeVariableElementImpl.EMPTY_ARRAY;
     }
-    return new List.from(_typeVariables);
+    List<TypeVariableElement> result = new List.from(_typeVariables);
+    _typeVariables = null;
+    return result;
+  }
+  void validate() {
+    JavaStringBuilder builder = new JavaStringBuilder();
+    if (_accessors != null) {
+      builder.append(_accessors.length);
+      builder.append(" accessors");
+    }
+    if (_constructors != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_constructors.length);
+      builder.append(" constructors");
+    }
+    if (_fields != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_fields.length);
+      builder.append(" fields");
+    }
+    if (_functions != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_functions.length);
+      builder.append(" functions");
+    }
+    if (_labels != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_labels.length);
+      builder.append(" labels");
+    }
+    if (_localVariables != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_localVariables.length);
+      builder.append(" local variables");
+    }
+    if (_methods != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_methods.length);
+      builder.append(" methods");
+    }
+    if (_parameters != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_parameters.length);
+      builder.append(" parameters");
+    }
+    if (_topLevelVariables != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_topLevelVariables.length);
+      builder.append(" top-level variables");
+    }
+    if (_types != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_types.length);
+      builder.append(" types");
+    }
+    if (_typeAliases != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_typeAliases.length);
+      builder.append(" type aliases");
+    }
+    if (_typeVariables != null) {
+      if (builder.length > 0) {
+        builder.append("; ");
+      }
+      builder.append(_typeVariables.length);
+      builder.append(" type variables");
+    }
+    if (builder.length > 0) {
+      AnalysisEngine.instance.logger.logError("Failed to capture elements: ${builder.toString()}");
+    }
   }
 }
 /**
- * Instances of the class {@code HtmlUnitBuilder} build an element model for a single HTML unit.
+ * Instances of the class `HtmlUnitBuilder` build an element model for a single HTML unit.
  */
 class HtmlUnitBuilder implements ht.XmlVisitor<Object> {
   static String _APPLICATION_DART_IN_DOUBLE_QUOTES = "\"application/dart\"";
   static String _APPLICATION_DART_IN_SINGLE_QUOTES = "'application/dart'";
   static String _SCRIPT = "script";
   static String _SRC = "src";
   static String _TYPE = "type";
 
   /**
    * The analysis context in which the element model will be built.
    */
   InternalAnalysisContext _context;
 
   /**
    * The error listener to which errors will be reported.
    */
   RecordingErrorListener _errorListener;
 
   /**
-   * The line information associated with the source for which an element is being built, or{@code null} if we are not building an element.
+   * The line information associated with the source for which an element is being built, or`null` if we are not building an element.
    */
   LineInfo _lineInfo;
 
   /**
    * The HTML element being built.
    */
   HtmlElementImpl _htmlElement;
 
   /**
    * The elements in the path from the HTML unit to the current tag node.
@@ skipping 138 matching lines @@
       } else {
         node.visitChildren(this);
       }
     } finally {
       _parentNodes.remove(node);
     }
     return null;
   }
 
   /**
-   * Return the first source attribute for the given tag node, or {@code null} if it does not exist.
+   * Return the first source attribute for the given tag node, or `null` if it does not exist.
    * @param node the node containing attributes
    * @return the source attribute contained in the given tag
    */
   ht.XmlAttributeNode getScriptSourcePath(ht.XmlTagNode node) {
     for (ht.XmlAttributeNode attribute in node.attributes) {
       if (attribute.name.lexeme == _SRC) {
         return attribute;
       }
     }
     return null;
   }
 
   /**
    * Determine if the specified node is a Dart script.
-   * @param node the node to be tested (not {@code null})
-   * @return {@code true} if the node is a Dart script
+   * @param node the node to be tested (not `null`)
+   * @return `true` if the node is a Dart script
    */
   bool isScriptNode(ht.XmlTagNode node) {
     if (node.tagNodes.length != 0 || node.tag.lexeme != _SCRIPT) {
       return false;
     }
     for (ht.XmlAttributeNode attribute in node.attributes) {
       if (attribute.name.lexeme == _TYPE) {
         ht.Token valueToken = attribute.value;
         if (valueToken != null) {
           String value = valueToken.lexeme;
@@ skipping 12 matching lines @@
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the first character to be highlighted
    * @param length the number of characters to be highlighted
    * @param arguments the arguments used to compose the error message
    */
   void reportError(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(_htmlElement.source, offset, length, errorCode, arguments));
   }
 }
 /**
- * Instances of the class {@code DeclarationResolver} are used to resolve declarations in an AST
+ * Instances of the class `DeclarationResolver` are used to resolve declarations in an AST
  * structure to already built elements.
  */
 class DeclarationResolver extends RecursiveASTVisitor<Object> {
 
   /**
    * The compilation unit containing the AST nodes being visited.
    */
   CompilationUnitElement _enclosingUnit;
 
   /**
-   * The function type alias containing the AST nodes being visited, or {@code null} if we are not
+   * The function type alias containing the AST nodes being visited, or `null` if we are not
    * in the scope of a function type alias.
    */
   FunctionTypeAliasElement _enclosingAlias;
 
   /**
-   * The class containing the AST nodes being visited, or {@code null} if we are not in the scope of
+   * The class containing the AST nodes being visited, or `null` if we are not in the scope of
    * a class.
    */
   ClassElement _enclosingClass;
 
   /**
-   * The method or function containing the AST nodes being visited, or {@code null} if we are not in
+   * The method or function containing the AST nodes being visited, or `null` if we are not in
    * the scope of a method or function.
    */
   ExecutableElement _enclosingExecutable;
 
   /**
-   * The parameter containing the AST nodes being visited, or {@code null} if we are not in the
+   * The parameter containing the AST nodes being visited, or `null` if we are not in the
    * scope of a parameter.
    */
   ParameterElement _enclosingParameter;
 
   /**
    * Resolve the declarations within the given compilation unit to the elements rooted at the given
    * element.
    * @param unit the compilation unit to be resolved
    * @param element the root of the element model used to resolve the AST nodes
    */
@@ skipping 325 matching lines @@
     } else if (literal is AdjacentStrings) {
       for (StringLiteral stringLiteral in ((literal as AdjacentStrings)).strings) {
         appendStringValue(builder, stringLiteral);
       }
     } else {
       throw new IllegalArgumentException();
     }
   }
 
   /**
-   * Return the element for the part with the given source, or {@code null} if there is no element
+   * Return the element for the part with the given source, or `null` if there is no element
    * for the given source.
    * @param parts the elements for the parts
    * @param partSource the source for the part whose element is to be returned
    * @return the element for the part with the given source
    */
   CompilationUnitElement find(List<CompilationUnitElement> parts, Source partSource) {
     for (CompilationUnitElement part in parts) {
       if (part.source == partSource) {
         return part;
       }
@@ skipping 34 matching lines @@
   Element find4(List<Element> elements, String name, int offset) {
     for (Element element in elements) {
       if (element.displayName == name && element.nameOffset == offset) {
         return element;
       }
     }
     return null;
   }
 
   /**
-   * Return the export element from the given array whose library has the given source, or{@code null} if there is no such export.
+   * Return the export element from the given array whose library has the given source, or`null` if there is no such export.
    * @param exports the export elements being searched
    * @param source the source of the library associated with the export element to being searched
    * for
    * @return the export element whose library has the given source
    */
   ExportElement find5(List<ExportElement> exports, Source source2) {
     for (ExportElement export in exports) {
       if (export.exportedLibrary.source == source2) {
         return export;
       }
     }
     return null;
   }
 
   /**
    * Return the import element from the given array whose library has the given source and that has
-   * the given prefix, or {@code null} if there is no such import.
+   * the given prefix, or `null` if there is no such import.
    * @param imports the import elements being searched
    * @param source the source of the library associated with the import element to being searched
    * for
    * @param prefix the prefix with which the library was imported
    * @return the import element whose library has the given source and prefix
    */
   ImportElement find6(List<ImportElement> imports, Source source2, SimpleIdentifier prefix2) {
     for (ImportElement element in imports) {
       if (element.importedLibrary.source == source2) {
         PrefixElement prefixElement = element.prefix;
         if (prefix2 == null) {
           if (prefixElement == null) {
             return element;
           }
         } else {
           if (prefixElement != null && prefix2.name == prefixElement.displayName) {
             return element;
           }
         }
       }
     }
     return null;
   }
 
   /**
-   * Return the value of the given string literal, or {@code null} if the string is not a constant
+   * Return the value of the given string literal, or `null` if the string is not a constant
    * string without any string interpolation.
    * @param literal the string literal whose value is to be returned
    * @return the value of the given string literal
    */
   String getStringValue(StringLiteral literal) {
     if (literal is StringInterpolation) {
       return null;
     }
     JavaStringBuilder builder = new JavaStringBuilder();
     try {
       appendStringValue(builder, literal);
     } on IllegalArgumentException catch (exception) {
       return null;
     }
     return builder.toString().trim();
   }
 }
 /**
- * Instances of the class {@code ElementResolver} are used by instances of {@link ResolverVisitor}to resolve references within the AST structure to the elements being referenced. The requirements
+ * Instances of the class `ElementResolver` are used by instances of [ResolverVisitor]to resolve references within the AST structure to the elements being referenced. The requirements
  * for the element resolver are:
  * <ol>
- * <li>Every {@link SimpleIdentifier} should be resolved to the element to which it refers.
+ * * Every [SimpleIdentifier] should be resolved to the element to which it refers.
  * Specifically:
- * <ul>
- * <li>An identifier within the declaration of that name should resolve to the element being
- * declared.</li>
- * <li>An identifier denoting a prefix should resolve to the element representing the import that
- * defines the prefix (an {@link ImportElement}).</li>
- * <li>An identifier denoting a variable should resolve to the element representing the variable (a{@link VariableElement}).</li>
- * <li>An identifier denoting a parameter should resolve to the element representing the parameter
- * (a {@link ParameterElement}).</li>
- * <li>An identifier denoting a field should resolve to the element representing the getter or
- * setter being invoked (a {@link PropertyAccessorElement}).</li>
- * <li>An identifier denoting the name of a method or function being invoked should resolve to the
- * element representing the method or function (a {@link ExecutableElement}).</li>
- * <li>An identifier denoting a label should resolve to the element representing the label (a{@link LabelElement}).</li>
- * </ul>
- * The identifiers within directives are exceptions to this rule and are covered below.</li>
- * <li>Every node containing a token representing an operator that can be overridden ({@link BinaryExpression}, {@link PrefixExpression}, {@link PostfixExpression}) should resolve to
- * the element representing the method invoked by that operator (a {@link MethodElement}).</li>
- * <li>Every {@link FunctionExpressionInvocation} should resolve to the element representing the
- * function being invoked (a {@link FunctionElement}). This will be the same element as that to
+ *
+ * * An identifier within the declaration of that name should resolve to the element being
+ * declared.
+ * * An identifier denoting a prefix should resolve to the element representing the import that
+ * defines the prefix (an [ImportElement]).
+ * * An identifier denoting a variable should resolve to the element representing the variable (a[VariableElement]).
+ * * An identifier denoting a parameter should resolve to the element representing the parameter
+ * (a [ParameterElement]).
+ * * An identifier denoting a field should resolve to the element representing the getter or
+ * setter being invoked (a [PropertyAccessorElement]).
+ * * An identifier denoting the name of a method or function being invoked should resolve to the
+ * element representing the method or function (a [ExecutableElement]).
+ * * An identifier denoting a label should resolve to the element representing the label (a[LabelElement]).
+ *
+ * The identifiers within directives are exceptions to this rule and are covered below.
+ * * Every node containing a token representing an operator that can be overridden ([BinaryExpression], [PrefixExpression], [PostfixExpression]) should resolve to
+ * the element representing the method invoked by that operator (a [MethodElement]).
+ * * Every [FunctionExpressionInvocation] should resolve to the element representing the
+ * function being invoked (a [FunctionElement]). This will be the same element as that to
  * which the name is resolved if the function has a name, but is provided for those cases where an
- * unnamed function is being invoked.</li>
- * <li>Every {@link LibraryDirective} and {@link PartOfDirective} should resolve to the element
- * representing the library being specified by the directive (a {@link LibraryElement}) unless, in
- * the case of a part-of directive, the specified library does not exist.</li>
- * <li>Every {@link ImportDirective} and {@link ExportDirective} should resolve to the element
+ * unnamed function is being invoked.
+ * * Every [LibraryDirective] and [PartOfDirective] should resolve to the element
+ * representing the library being specified by the directive (a [LibraryElement]) unless, in
+ * the case of a part-of directive, the specified library does not exist.
+ * * Every [ImportDirective] and [ExportDirective] should resolve to the element
  * representing the library being specified by the directive unless the specified library does not
- * exist (an {@link ImportElement} or {@link ExportElement}).</li>
- * <li>The identifier representing the prefix in an {@link ImportDirective} should resolve to the
- * element representing the prefix (a {@link PrefixElement}).</li>
- * <li>The identifiers in the hide and show combinators in {@link ImportDirective}s and{@link ExportDirective}s should resolve to the elements that are being hidden or shown,
+ * exist (an [ImportElement] or [ExportElement]).
+ * * The identifier representing the prefix in an [ImportDirective] should resolve to the
+ * element representing the prefix (a [PrefixElement]).
+ * * The identifiers in the hide and show combinators in [ImportDirective]s and[ExportDirective]s should resolve to the elements that are being hidden or shown,
  * respectively, unless those names are not defined in the specified library (or the specified
- * library does not exist).</li>
- * <li>Every {@link PartDirective} should resolve to the element representing the compilation unit
- * being specified by the string unless the specified compilation unit does not exist (a{@link CompilationUnitElement}).</li>
+ * library does not exist).
+ * * Every [PartDirective] should resolve to the element representing the compilation unit
+ * being specified by the string unless the specified compilation unit does not exist (a[CompilationUnitElement]).
  * </ol>
  * Note that AST nodes that would represent elements that are not defined are not resolved to
  * anything. This includes such things as references to undeclared variables (which is an error) and
  * names in hide and show combinators that are not defined in the imported library (which is not an
  * error).
  * @coverage dart.engine.resolver
  */
 class ElementResolver extends SimpleASTVisitor<Object> {
 
   /**
-   * @return {@code true} if the given identifier is the return type of a constructor declaration.
+   * @return `true` if the given identifier is the return type of a constructor declaration.
    */
   static bool isConstructorReturnType(SimpleIdentifier node) {
     ASTNode parent = node.parent;
     if (parent is ConstructorDeclaration) {
       ConstructorDeclaration constructor = parent as ConstructorDeclaration;
       return identical(constructor.returnType, node);
     }
     return false;
   }
 
   /**
-   * @return {@code true} if the given identifier is the return type of a factory constructor
+   * @return `true` if the given identifier is the return type of a factory constructor
    * declaration.
    */
   static bool isFactoryConstructorReturnType(SimpleIdentifier node) {
     ASTNode parent = node.parent;
     if (parent is ConstructorDeclaration) {
       ConstructorDeclaration constructor = parent as ConstructorDeclaration;
       return identical(constructor.returnType, node) && constructor.factoryKeyword != null;
     }
     return false;
   }
 
   /**
    * Checks if the given 'super' expression is used in the valid context.
    * @param node the 'super' expression to analyze
-   * @return {@code true} if the given 'super' expression is in the valid context
+   * @return `true` if the given 'super' expression is in the valid context
    */
   static bool isSuperInValidContext(SuperExpression node) {
     for (ASTNode n = node; n != null; n = n.parent) {
       if (n is CompilationUnit) {
         return false;
       }
       if (n is ConstructorDeclaration) {
         ConstructorDeclaration constructor = n as ConstructorDeclaration;
         return constructor.factoryKeyword == null;
       }
@@ skipping 101 matching lines @@
       SimpleIdentifier simpleIdentifier = identifier as SimpleIdentifier;
       Element element = resolveSimpleIdentifier(simpleIdentifier);
       if (element == null) {
         element = findImportWithoutPrefix(simpleIdentifier);
         if (element is MultiplyDefinedElement) {
           element = null;
         }
       }
       if (element == null) {
       } else {
-        if (element.library != _resolver.definingLibrary) {
+        if (element.library == null || element.library != _resolver.definingLibrary) {
         }
         recordResolution(simpleIdentifier, element);
         if (node.newKeyword != null) {
           if (element is ClassElement) {
             ConstructorElement constructor = ((element as ClassElement)).unnamedConstructor;
             if (constructor == null) {
             } else {
               recordResolution(simpleIdentifier, constructor);
             }
           } else {
@@ skipping 493 matching lines @@
     for (Annotation annotationNode in annotations) {
       Element resolvedElement = annotationNode.element;
       if (resolvedElement != null) {
         annotationList.add(new ElementAnnotationImpl(resolvedElement));
       }
     }
   }
 
   /**
    * Given that we have found code to invoke the given element, return the error code that should be
-   * reported, or {@code null} if no error should be reported.
-   * @param target the target of the invocation, or {@code null} if there was no target
+   * reported, or `null` if no error should be reported.
+   * @param target the target of the invocation, or `null` if there was no target
    * @param element the element to be invoked
    * @return the error code that should be reported
    */
   ErrorCode checkForInvocationError(Expression target, Element element2) {
     if (element2 is PropertyAccessorElement) {
       FunctionType getterType = ((element2 as PropertyAccessorElement)).type;
       if (getterType != null) {
         Type2 returnType = getterType.returnType;
         if (!isExecutableType(returnType)) {
           return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
@@ skipping 40 matching lines @@
           } else if (!targetType.isDynamic() && !classDeclaresNoSuchMethod2(targetType.element)) {
             return StaticTypeWarningCode.UNDEFINED_METHOD;
           }
         }
       }
     }
     return null;
   }
 
   /**
-   * Return {@code true} if the given class declares a method named "noSuchMethod" and is not the
+   * Return `true` if the given class declares a method named "noSuchMethod" and is not the
    * class 'Object'.
    * @param element the class being tested
-   * @return {@code true} if the given class declares a method named "noSuchMethod"
+   * @return `true` if the given class declares a method named "noSuchMethod"
    */
   bool classDeclaresNoSuchMethod(ClassElement classElement) {
     if (classElement == null) {
       return false;
     }
     MethodElement methodElement = classElement.lookUpMethod(_NO_SUCH_METHOD_METHOD_NAME, _resolver.definingLibrary);
     return methodElement != null && methodElement.enclosingElement.supertype != null;
   }
 
   /**
-   * Return {@code true} if the given element represents a class that declares a method named
+   * Return `true` if the given element represents a class that declares a method named
    * "noSuchMethod" and is not the class 'Object'.
    * @param element the element being tested
-   * @return {@code true} if the given element represents a class that declares a method named
+   * @return `true` if the given element represents a class that declares a method named
    * "noSuchMethod"
    */
   bool classDeclaresNoSuchMethod2(Element element) {
     if (element is ClassElement) {
       return classDeclaresNoSuchMethod((element as ClassElement));
     }
     return false;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
-   * correspond to the arguments, or {@code null} if no correspondence could be computed.
+   * correspond to the arguments, or `null` if no correspondence could be computed.
    * @param argumentList the list of arguments being passed to the element
    * @param executableElement the element that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
   List<ParameterElement> computePropagatedParameters(ArgumentList argumentList, Element element2) {
     if (element2 is PropertyAccessorElement) {
       FunctionType getterType = ((element2 as PropertyAccessorElement)).type;
       if (getterType != null) {
         Type2 getterReturnType = getterType.returnType;
         if (getterReturnType is InterfaceType) {
@@ skipping 36 matching lines @@
    */
   Element convertSetterToGetter(Element element) {
     if (element is PropertyAccessorElement) {
       return ((element as PropertyAccessorElement)).variable.getter;
     }
     return element;
   }
 
   /**
    * Look for any declarations of the given identifier that are imported using a prefix. Return the
-   * element that was found, or {@code null} if the name is not imported using a prefix.
+   * element that was found, or `null` if the name is not imported using a prefix.
    * @param identifier the identifier that might have been imported using a prefix
    * @return the element that was found
    */
   Element findImportWithoutPrefix(SimpleIdentifier identifier) {
     Element element = null;
     Scope nameScope = _resolver.nameScope;
     LibraryElement definingLibrary = _resolver.definingLibrary;
     for (ImportElement importElement in definingLibrary.imports) {
       PrefixElement prefixElement = importElement.prefix;
       if (prefixElement != null) {
@@ skipping 73 matching lines @@
    */
   ClassElement getSuperclass(ClassElement targetClass) {
     InterfaceType superType = targetClass.supertype;
     if (superType == null) {
       return null;
     }
     return superType.element;
   }
 
   /**
-   * Return {@code true} if the given type represents an object that could be invoked using the call
+   * Return `true` if the given type represents an object that could be invoked using the call
    * operator '()'.
    * @param type the type being tested
-   * @return {@code true} if the given type represents an object that could be invoked
+   * @return `true` if the given type represents an object that could be invoked
    */
   bool isExecutableType(Type2 type) {
     if (type.isDynamic() || (type is FunctionType) || type.isDartCoreFunction()) {
       return true;
     } else if (type is InterfaceType) {
       ClassElement classElement = ((type as InterfaceType)).element;
       MethodElement methodElement = classElement.lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
       return methodElement != null;
     }
     return false;
   }
 
   /**
-   * Return {@code true} if the given element is a static element.
+   * Return `true` if the given element is a static element.
    * @param element the element being tested
-   * @return {@code true} if the given element is a static element
+   * @return `true` if the given element is a static element
    */
   bool isStatic(Element element) {
     if (element is ExecutableElement) {
       return ((element as ExecutableElement)).isStatic();
     } else if (element is PropertyInducingElement) {
       return ((element as PropertyInducingElement)).isStatic();
     }
     return false;
   }
 
   /**
-   * Looks up the method element with the given name for index expression, reports{@link StaticWarningCode#UNDEFINED_OPERATOR} if not found.
+   * Looks up the method element with the given name for index expression, reports[StaticWarningCode#UNDEFINED_OPERATOR] if not found.
    * @param node the index expression to resolve
    * @param target the target of the expression
    * @param methodName the name of the operator associated with the context of using of the given
    * index expression
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    */
   bool lookUpCheckIndexOperator(IndexExpression node, Expression target, String methodName, Type2 staticType, Type2 propagatedType) {
     MethodElement staticMethod = lookUpMethod(target, staticType, methodName);
     MethodElement propagatedMethod = lookUpMethod(target, propagatedType, methodName);
     node.staticElement = staticMethod;
     node.element = select3(staticMethod, propagatedMethod);
     if (shouldReportMissingMember(staticType, staticMethod) && (_strictMode || propagatedType == null || shouldReportMissingMember(propagatedType, propagatedMethod))) {
       sc.Token leftBracket = node.leftBracket;
       sc.Token rightBracket = node.rightBracket;
       if (leftBracket == null || rightBracket == null) {
         _resolver.reportError(StaticTypeWarningCode.UNDEFINED_OPERATOR, node, [methodName, staticType.displayName]);
         return true;
       } else {
         int offset = leftBracket.offset;
         int length = rightBracket.offset - offset + 1;
         _resolver.reportError5(StaticTypeWarningCode.UNDEFINED_OPERATOR, offset, length, [methodName, staticType.displayName]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * Look up the getter with the given name in the given type. Return the element representing the
-   * getter that was found, or {@code null} if there is no getter with the given name.
-   * @param target the target of the invocation, or {@code null} if there is no target
+   * getter that was found, or `null` if there is no getter with the given name.
+   * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the getter is defined
    * @param getterName the name of the getter being looked up
    * @return the element representing the getter that was found
    */
   PropertyAccessorElement lookUpGetter(Expression target, Type2 type, String getterName) {
     type = resolveTypeVariable(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type as InterfaceType;
       PropertyAccessorElement accessor;
       if (target is SuperExpression) {
         accessor = interfaceType.lookUpGetterInSuperclass(getterName, _resolver.definingLibrary);
       } else {
         accessor = interfaceType.lookUpGetter(getterName, _resolver.definingLibrary);
       }
       if (accessor != null) {
         return accessor;
       }
       return lookUpGetterInInterfaces(interfaceType, false, getterName, new Set<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the getter with the given name in the interfaces implemented by the given type, either
-   * directly or indirectly. Return the element representing the getter that was found, or{@code null} if there is no getter with the given name.
+   * directly or indirectly. Return the element representing the getter that was found, or`null` if there is no getter with the given name.
    * @param targetType the type in which the getter might be defined
-   * @param includeTargetType {@code true} if the search should include the target type
+   * @param includeTargetType `true` if the search should include the target type
    * @param getterName the name of the getter being looked up
    * @param visitedInterfaces a set containing all of the interfaces that have been examined, used
    * to prevent infinite recursion and to optimize the search
    * @return the element representing the getter that was found
    */
   PropertyAccessorElement lookUpGetterInInterfaces(InterfaceType targetType, bool includeTargetType, String getterName, Set<ClassElement> visitedInterfaces) {
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
@@ skipping 18 matching lines @@
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
     return lookUpGetterInInterfaces(superclass, true, getterName, visitedInterfaces);
   }
 
   /**
    * Look up the method or getter with the given name in the given type. Return the element
-   * representing the method or getter that was found, or {@code null} if there is no method or
+   * representing the method or getter that was found, or `null` if there is no method or
    * getter with the given name.
    * @param type the type in which the method or getter is defined
    * @param memberName the name of the method or getter being looked up
    * @return the element representing the method or getter that was found
    */
   ExecutableElement lookupGetterOrMethod(Type2 type, String memberName) {
     type = resolveTypeVariable(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type as InterfaceType;
       ExecutableElement member = interfaceType.lookUpMethod(memberName, _resolver.definingLibrary);
       if (member != null) {
         return member;
       }
       member = interfaceType.lookUpGetter(memberName, _resolver.definingLibrary);
       if (member != null) {
         return member;
       }
       return lookUpGetterOrMethodInInterfaces(interfaceType, false, memberName, new Set<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the method or getter with the given name in the interfaces implemented by the given
    * type, either directly or indirectly. Return the element representing the method or getter that
-   * was found, or {@code null} if there is no method or getter with the given name.
+   * was found, or `null` if there is no method or getter with the given name.
    * @param targetType the type in which the method or getter might be defined
-   * @param includeTargetType {@code true} if the search should include the target type
+   * @param includeTargetType `true` if the search should include the target type
    * @param memberName the name of the method or getter being looked up
    * @param visitedInterfaces a set containing all of the interfaces that have been examined, used
    * to prevent infinite recursion and to optimize the search
    * @return the element representing the method or getter that was found
    */
   ExecutableElement lookUpGetterOrMethodInInterfaces(InterfaceType targetType, bool includeTargetType, String memberName, Set<ClassElement> visitedInterfaces) {
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
@@ skipping 61 matching lines @@
       if (labelContainer != _resolver.enclosingFunction) {
         _resolver.reportError(CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE, labelNode, [labelNode.name]);
         labelElement = null;
       }
     }
     return labelElement;
   }
 
   /**
    * Look up the method with the given name in the given type. Return the element representing the
-   * method that was found, or {@code null} if there is no method with the given name.
-   * @param target the target of the invocation, or {@code null} if there is no target
+   * method that was found, or `null` if there is no method with the given name.
+   * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the method is defined
    * @param methodName the name of the method being looked up
    * @return the element representing the method that was found
    */
   MethodElement lookUpMethod(Expression target, Type2 type, String methodName) {
     type = resolveTypeVariable(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type as InterfaceType;
       MethodElement method;
       if (target is SuperExpression) {
         method = interfaceType.lookUpMethodInSuperclass(methodName, _resolver.definingLibrary);
       } else {
         method = interfaceType.lookUpMethod(methodName, _resolver.definingLibrary);
       }
       if (method != null) {
         return method;
       }
       return lookUpMethodInInterfaces(interfaceType, false, methodName, new Set<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the method with the given name in the interfaces implemented by the given type, either
-   * directly or indirectly. Return the element representing the method that was found, or{@code null} if there is no method with the given name.
+   * directly or indirectly. Return the element representing the method that was found, or`null` if there is no method with the given name.
    * @param targetType the type in which the member might be defined
-   * @param includeTargetType {@code true} if the search should include the target type
+   * @param includeTargetType `true` if the search should include the target type
    * @param methodName the name of the method being looked up
    * @param visitedInterfaces a set containing all of the interfaces that have been examined, used
    * to prevent infinite recursion and to optimize the search
    * @return the element representing the method that was found
    */
   MethodElement lookUpMethodInInterfaces(InterfaceType targetType, bool includeTargetType, String methodName, Set<ClassElement> visitedInterfaces) {
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
@@ skipping 18 matching lines @@
     }
     InterfaceType superclass = targetType.superclass;
     if (superclass == null) {
       return null;
     }
     return lookUpMethodInInterfaces(superclass, true, methodName, visitedInterfaces);
   }
 
   /**
    * Look up the setter with the given name in the given type. Return the element representing the
-   * setter that was found, or {@code null} if there is no setter with the given name.
-   * @param target the target of the invocation, or {@code null} if there is no target
+   * setter that was found, or `null` if there is no setter with the given name.
+   * @param target the target of the invocation, or `null` if there is no target
    * @param type the type in which the setter is defined
    * @param setterName the name of the setter being looked up
    * @return the element representing the setter that was found
    */
   PropertyAccessorElement lookUpSetter(Expression target, Type2 type, String setterName) {
     type = resolveTypeVariable(type);
     if (type is InterfaceType) {
       InterfaceType interfaceType = type as InterfaceType;
       PropertyAccessorElement accessor;
       if (target is SuperExpression) {
         accessor = interfaceType.lookUpSetterInSuperclass(setterName, _resolver.definingLibrary);
       } else {
         accessor = interfaceType.lookUpSetter(setterName, _resolver.definingLibrary);
       }
       if (accessor != null) {
         return accessor;
       }
       return lookUpSetterInInterfaces(interfaceType, false, setterName, new Set<ClassElement>());
     }
     return null;
   }
 
   /**
    * Look up the setter with the given name in the interfaces implemented by the given type, either
-   * directly or indirectly. Return the element representing the setter that was found, or{@code null} if there is no setter with the given name.
+   * directly or indirectly. Return the element representing the setter that was found, or`null` if there is no setter with the given name.
    * @param targetType the type in which the setter might be defined
-   * @param includeTargetType {@code true} if the search should include the target type
+   * @param includeTargetType `true` if the search should include the target type
    * @param setterName the name of the setter being looked up
    * @param visitedInterfaces a set containing all of the interfaces that have been examined, used
    * to prevent infinite recursion and to optimize the search
    * @return the element representing the setter that was found
    */
   PropertyAccessorElement lookUpSetterInInterfaces(InterfaceType targetType, bool includeTargetType, String setterName, Set<ClassElement> visitedInterfaces) {
     ClassElement targetClass = targetType.element;
     if (visitedInterfaces.contains(targetClass)) {
       return null;
     }
@@ skipping 79 matching lines @@
    * @return the element that was associated with the node
    */
   void recordResolution2(SimpleIdentifier node, Element staticElement2, Element propagatedElement) {
     node.staticElement = staticElement2;
     node.element = propagatedElement == null ? staticElement2 : propagatedElement;
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
-   * correspond to the arguments, or {@code null} if no correspondence could be computed.
-   * @param reportError if {@code true} then compile-time error should be reported; if {@code false}then compile-time warning
+   * correspond to the arguments, or `null` if no correspondence could be computed.
+   * @param reportError if `true` then compile-time error should be reported; if `false`then compile-time warning
    * @param argumentList the list of arguments being passed to the element
    * @param executableElement the element that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
   List<ParameterElement> resolveArgumentsToParameters(bool reportError, ArgumentList argumentList, ExecutableElement executableElement) {
     if (executableElement == null) {
       return null;
     }
     List<ParameterElement> parameters = executableElement.parameters;
     return resolveArgumentsToParameters2(reportError, argumentList, parameters);
   }
 
   /**
    * Given a list of arguments and the parameters related to the element that will be invoked using
    * those argument, compute the list of parameters that correspond to the list of arguments. Return
    * the parameters that correspond to the arguments.
-   * @param reportError if {@code true} then compile-time error should be reported; if {@code false}then compile-time warning
+   * @param reportError if `true` then compile-time error should be reported; if `false`then compile-time warning
    * @param argumentList the list of arguments being passed to the element
    * @param parameters the of the function that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
   List<ParameterElement> resolveArgumentsToParameters2(bool reportError2, ArgumentList argumentList, List<ParameterElement> parameters) {
     List<ParameterElement> requiredParameters = new List<ParameterElement>();
     List<ParameterElement> positionalParameters = new List<ParameterElement>();
     Map<String, ParameterElement> namedParameters = new Map<String, ParameterElement>();
     for (ParameterElement parameter in parameters) {
       ParameterKind kind = parameter.parameterKind;
@@ skipping 176 matching lines @@
           }
         } else {
           _resolver.reportError(StaticWarningCode.UNDEFINED_IDENTIFIER, propertyName, [propertyName.name]);
         }
       }
     }
   }
 
   /**
    * Resolve the given simple identifier if possible. Return the element to which it could be
-   * resolved, or {@code null} if it could not be resolved. This does not record the results of the
+   * resolved, or `null` if it could not be resolved. This does not record the results of the
    * resolution.
    * @param node the identifier to be resolved
    * @return the element to which the identifier could be resolved
    */
   Element resolveSimpleIdentifier(SimpleIdentifier node) {
     Element element = _resolver.nameScope.lookup(node, _resolver.definingLibrary);
     if (element is PropertyAccessorElement && node.inSetterContext()) {
       PropertyInducingElement variable = ((element as PropertyAccessorElement)).variable;
       if (variable != null) {
         PropertyAccessorElement setter = variable.setter;
@@ skipping 40 matching lines @@
         return _resolver.typeProvider.objectType;
       }
       return bound;
     }
     return type;
   }
 
   /**
    * Given two possible error codes for the same piece of code, one computed using static type
    * information and the other using propagated type information, return the error code that should
-   * be reported, or {@code null} if no error should be reported.
+   * be reported, or `null` if no error should be reported.
    * @param staticError the error code computed using static type information
    * @param propagatedError the error code computed using propagated type information
    * @return the error code that should be reported
    */
   ErrorCode select(ErrorCode staticError, ErrorCode propagatedError) {
     if (staticError == null || propagatedError == null) {
       return null;
     }
     return propagatedError;
   }
 
   /**
-   * Return the propagated element if it is not {@code null}, or the static element if it is.
+   * Return the propagated element if it is not `null`, or the static element if it is.
    * @param staticElement the element computed using static type information
    * @param propagatedElement the element computed using propagated type information
    * @return the more specific of the two elements
    */
   ExecutableElement select2(ExecutableElement staticElement, ExecutableElement propagatedElement) => propagatedElement != null ? propagatedElement : staticElement;
 
   /**
-   * Return the propagated method if it is not {@code null}, or the static method if it is.
+   * Return the propagated method if it is not `null`, or the static method if it is.
    * @param staticMethod the method computed using static type information
    * @param propagatedMethod the method computed using propagated type information
    * @return the more specific of the two methods
    */
   MethodElement select3(MethodElement staticMethod, MethodElement propagatedMethod) => propagatedMethod != null ? propagatedMethod : staticMethod;
 
   /**
    * Given a node that can have annotations associated with it and the element to which that node
    * has been resolved, create the annotations in the element model representing the annotations on
    * the node.
@@ skipping 16 matching lines @@
         TopLevelVariableDeclaration variableDeclaration = list.parent as TopLevelVariableDeclaration;
         addAnnotations(annotationList, variableDeclaration.metadata);
       }
     }
     if (!annotationList.isEmpty) {
       ((element as ElementImpl)).metadata = new List.from(annotationList);
     }
   }
 
   /**
-   * Return {@code true} if we should report an error as a result of looking up a member in the
+   * Return `true` if we should report an error as a result of looking up a member in the
    * given type and not finding any member.
    * @param type the type in which we attempted to perform the look-up
    * @param member the result of the look-up
-   * @return {@code true} if we should report an error
+   * @return `true` if we should report an error
    */
   bool shouldReportMissingMember(Type2 type, ExecutableElement member) {
     if (member != null || type == null || type.isDynamic()) {
       return false;
     }
     if (type is InterfaceType) {
       return !classDeclaresNoSuchMethod(((type as InterfaceType)).element);
     }
     return true;
   }
 }
 /**
- * Instances of the class {@code SyntheticIdentifier} implement an identifier that can be used to
+ * Instances of the class `SyntheticIdentifier` implement an identifier that can be used to
  * look up names in the lexical scope when there is no identifier in the AST structure. There is
  * no identifier in the AST when the parser could not distinguish between a method invocation and
  * an invocation of a top-level function imported with a prefix.
  */
 class ElementResolver_SyntheticIdentifier extends Identifier {
 
   /**
    * The name of the synthetic identifier.
    */
   String _name;
 
   /**
    * Initialize a newly created synthetic identifier to have the given name.
    * @param name the name of the synthetic identifier
    */
   ElementResolver_SyntheticIdentifier(String name) {
     this._name = name;
   }
   accept(ASTVisitor visitor) => null;
   sc.Token get beginToken => null;
   Element get element => null;
   sc.Token get endToken => null;
   String get name => _name;
   Element get staticElement => null;
   void visitChildren(ASTVisitor<Object> visitor) {
   }
 }
 /**
- * Instances of the class {@code InheritanceManager} manage the knowledge of where class members
+ * Instances of the class `InheritanceManager` manage the knowledge of where class members
  * (methods, getters & setters) are inherited from.
  * @coverage dart.engine.resolver
  */
 class InheritanceManager {
 
   /**
-   * The {@link LibraryElement} that is managed by this manager.
+   * The [LibraryElement] that is managed by this manager.
    */
   LibraryElement _library;
 
   /**
-   * This is a mapping between each {@link ClassElement} and a map between the {@link String} member
-   * names and the associated {@link ExecutableElement} in the mixin and superclass chain.
+   * This is a mapping between each [ClassElement] and a map between the [String] member
+   * names and the associated [ExecutableElement] in the mixin and superclass chain.
    */
   Map<ClassElement, Map<String, ExecutableElement>> _classLookup;
 
   /**
-   * This is a mapping between each {@link ClassElement} and a map between the {@link String} member
-   * names and the associated {@link ExecutableElement} in the interface set.
+   * This is a mapping between each [ClassElement] and a map between the [String] member
+   * names and the associated [ExecutableElement] in the interface set.
    */
   Map<ClassElement, Map<String, ExecutableElement>> _interfaceLookup;
 
   /**
-   * A map between each visited {@link ClassElement} and the set of {@link AnalysisError}s found on
+   * A map between each visited [ClassElement] and the set of [AnalysisError]s found on
    * the class element.
    */
   Map<ClassElement, Set<AnalysisError>> _errorsInClassElement = new Map<ClassElement, Set<AnalysisError>>();
 
   /**
    * Initialize a newly created inheritance manager.
    * @param library the library element context that the inheritance mappings are being generated
    */
   InheritanceManager(LibraryElement library) {
     this._library = library;
     _classLookup = new Map<ClassElement, Map<String, ExecutableElement>>();
     _interfaceLookup = new Map<ClassElement, Map<String, ExecutableElement>>();
   }
 
   /**
-   * Return the set of {@link AnalysisError}s found on the passed {@link ClassElement}, or{@code null} if there are none.
+   * Return the set of [AnalysisError]s found on the passed [ClassElement], or`null` if there are none.
    * @param classElt the class element to query
-   * @return the set of {@link AnalysisError}s found on the passed {@link ClassElement}, or{@code null} if there are none
+   * @return the set of [AnalysisError]s found on the passed [ClassElement], or`null` if there are none
    */
   Set<AnalysisError> getErrors(ClassElement classElt) => _errorsInClassElement[classElt];
 
   /**
    * Get and return a mapping between the set of all string names of the members inherited from the
-   * passed {@link ClassElement} superclass hierarchy, and the associated {@link ExecutableElement}.
+   * passed [ClassElement] superclass hierarchy, and the associated [ExecutableElement].
    * @param classElt the class element to query
-   * @return a mapping between the set of all members inherited from the passed {@link ClassElement}superclass hierarchy, and the associated {@link ExecutableElement}
+   * @return a mapping between the set of all members inherited from the passed [ClassElement]superclass hierarchy, and the associated [ExecutableElement]
    */
   Map<String, ExecutableElement> getMapOfMembersInheritedFromClasses(ClassElement classElt) => computeClassChainLookupMap(classElt, new Set<ClassElement>());
 
   /**
    * Get and return a mapping between the set of all string names of the members inherited from the
-   * passed {@link ClassElement} interface hierarchy, and the associated {@link ExecutableElement}.
+   * passed [ClassElement] interface hierarchy, and the associated [ExecutableElement].
    * @param classElt the class element to query
-   * @return a mapping between the set of all string names of the members inherited from the passed{@link ClassElement} interface hierarchy, and the associated {@link ExecutableElement}.
+   * @return a mapping between the set of all string names of the members inherited from the passed[ClassElement] interface hierarchy, and the associated [ExecutableElement].
    */
   Map<String, ExecutableElement> getMapOfMembersInheritedFromInterfaces(ClassElement classElt) => computeInterfaceLookupMap(classElt, new Set<ClassElement>());
 
   /**
-   * Given some {@link ClassElement class element} and some member name, this returns the{@link ExecutableElement executable element} that the class inherits from the mixins,
-   * superclasses or interfaces, that has the member name, if no member is inherited {@code null} is
+   * Given some [ClassElement class element] and some member name, this returns the[ExecutableElement executable element] that the class inherits from the mixins,
+   * superclasses or interfaces, that has the member name, if no member is inherited `null` is
    * returned.
    * @param classElt the class element to query
    * @param memberName the name of the executable element to find and return
-   * @return the inherited executable element with the member name, or {@code null} if no such
+   * @return the inherited executable element with the member name, or `null` if no such
    * member exists
    */
   ExecutableElement lookupInheritance(ClassElement classElt, String memberName) {
     if (memberName == null || memberName.isEmpty) {
       return null;
     }
     ExecutableElement executable = computeClassChainLookupMap(classElt, new Set<ClassElement>())[memberName];
     if (executable == null) {
       return computeInterfaceLookupMap(classElt, new Set<ClassElement>())[memberName];
     }
     return executable;
   }
 
   /**
-   * Given some {@link ClassElement class element} and some member name, this returns the{@link ExecutableElement executable element} that the class either declares itself, or
-   * inherits, that has the member name, if no member is inherited {@code null} is returned.
+   * Given some [ClassElement class element] and some member name, this returns the[ExecutableElement executable element] that the class either declares itself, or
+   * inherits, that has the member name, if no member is inherited `null` is returned.
    * @param classElt the class element to query
    * @param memberName the name of the executable element to find and return
-   * @return the inherited executable element with the member name, or {@code null} if no such
+   * @return the inherited executable element with the member name, or `null` if no such
    * member exists
    */
   ExecutableElement lookupMember(ClassElement classElt, String memberName) {
     ExecutableElement element = lookupMemberInClass(classElt, memberName);
     if (element != null) {
       return element;
     }
     return lookupInheritance(classElt, memberName);
   }
 
   /**
    * Set the new library element context.
    * @param library the new library element
    */
   void set libraryElement(LibraryElement library2) {
     this._library = library2;
   }
 
   /**
-   * This method takes some inherited {@link FunctionType}, and resolves all the parameterized types
+   * This method takes some inherited [FunctionType], and resolves all the parameterized types
    * in the function type, dependent on the class in which it is being overridden.
    * @param baseFunctionType the function type that is being overridden
    * @param memberName the name of the member, this is used to lookup the inheritance path of the
    * override
    * @param definingType the type that is overriding the member
    * @return the passed function type with any parameterized types substituted
    */
   FunctionType substituteTypeArgumentsInMemberFromInheritance(FunctionType baseFunctionType, String memberName, InterfaceType definingType) {
     if (baseFunctionType == null) {
       return baseFunctionType;
     }
     Queue<InterfaceType> inheritancePath = new Queue<InterfaceType>();
     computeInheritancePath(inheritancePath, definingType, memberName);
     if (inheritancePath == null || inheritancePath.length < 2) {
       return baseFunctionType;
     }
     FunctionType functionTypeToReturn = baseFunctionType;
     InterfaceType lastType = inheritancePath.removeLast();
     while (inheritancePath.length > 0) {
-      List<Type2> paramTypes = TypeVariableTypeImpl.getTypes(lastType.element.typeVariables);
-      List<Type2> argTypes = lastType.typeArguments;
-      functionTypeToReturn = functionTypeToReturn.substitute2(argTypes, paramTypes);
+      List<Type2> parameterTypes = lastType.element.type.typeArguments;
+      List<Type2> argumentTypes = lastType.typeArguments;
+      functionTypeToReturn = functionTypeToReturn.substitute2(argumentTypes, parameterTypes);
       lastType = inheritancePath.removeLast();
     }
     return functionTypeToReturn;
   }
 
   /**
    * Compute and return a mapping between the set of all string names of the members inherited from
-   * the passed {@link ClassElement} superclass hierarchy, and the associated{@link ExecutableElement}.
+   * the passed [ClassElement] superclass hierarchy, and the associated[ExecutableElement].
    * @param classElt the class element to query
    * @param visitedClasses a set of visited classes passed back into this method when it calls
    * itself recursively
-   * @return a mapping between the set of all string names of the members inherited from the passed{@link ClassElement} superclass hierarchy, and the associated {@link ExecutableElement}
+   * @return a mapping between the set of all string names of the members inherited from the passed[ClassElement] superclass hierarchy, and the associated [ExecutableElement]
    */
   Map<String, ExecutableElement> computeClassChainLookupMap(ClassElement classElt, Set<ClassElement> visitedClasses) {
     Map<String, ExecutableElement> resultMap = _classLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
       resultMap = new Map<String, ExecutableElement>();
     }
     ClassElement superclassElt = null;
     InterfaceType supertype = classElt.supertype;
@@ skipping 21 matching lines @@
       }
     }
     _classLookup[classElt] = resultMap;
     return resultMap;
   }
 
   /**
    * Compute and return the inheritance path given the context of a type and a member that is
    * overridden in the inheritance path (for which the type is in the path).
    * @param chain the inheritance path that is built up as this method calls itself recursively,
-   * when this method is called an empty {@link LinkedList} should be provided
+   * when this method is called an empty [LinkedList] should be provided
    * @param currentType the current type in the inheritance path
    * @param memberName the name of the member that is being looked up the inheritance path
    */
   void computeInheritancePath(Queue<InterfaceType> chain, InterfaceType currentType, String memberName) {
     chain.add(currentType);
     ClassElement classElt = currentType.element;
     InterfaceType supertype = classElt.supertype;
     if (supertype == null) {
       return;
     }
@@ skipping 23 matching lines @@
       ClassElement interfaceElement = interfaceType.element;
       if (interfaceElement != null && lookupMember(interfaceElement, memberName) != null) {
         computeInheritancePath(chain, interfaceType, memberName);
         return;
       }
     }
   }
 
   /**
    * Compute and return a mapping between the set of all string names of the members inherited from
-   * the passed {@link ClassElement} interface hierarchy, and the associated{@link ExecutableElement}.
+   * the passed [ClassElement] interface hierarchy, and the associated[ExecutableElement].
    * @param classElt the class element to query
    * @param visitedInterfaces a set of visited classes passed back into this method when it calls
    * itself recursively
-   * @return a mapping between the set of all string names of the members inherited from the passed{@link ClassElement} interface hierarchy, and the associated {@link ExecutableElement}
+   * @return a mapping between the set of all string names of the members inherited from the passed[ClassElement] interface hierarchy, and the associated [ExecutableElement]
    */
   Map<String, ExecutableElement> computeInterfaceLookupMap(ClassElement classElt, Set<ClassElement> visitedInterfaces) {
     Map<String, ExecutableElement> resultMap = _interfaceLookup[classElt];
     if (resultMap != null) {
       return resultMap;
     } else {
       resultMap = new Map<String, ExecutableElement>();
     }
     InterfaceType supertype = classElt.supertype;
     ClassElement superclassElement = supertype != null ? supertype.element : null;
     List<InterfaceType> interfaces = classElt.interfaces;
-    if (superclassElement == null || interfaces.length == 0) {
+    if ((superclassElement == null || supertype.isObject()) && interfaces.length == 0) {
       _interfaceLookup[classElt] = resultMap;
       return resultMap;
     }
     List<Map<String, ExecutableElement>> lookupMaps = new List<Map<String, ExecutableElement>>();
     if (superclassElement != null) {
       if (!visitedInterfaces.contains(superclassElement)) {
         try {
           javaSetAdd(visitedInterfaces, superclassElement);
           lookupMaps.add(computeInterfaceLookupMap(superclassElement, visitedInterfaces));
         } finally {
@@ skipping 165 matching lines @@
           }
           resultMap.remove(entry.getKey());
         }
       }
     }
     _interfaceLookup[classElt] = resultMap;
     return resultMap;
   }
 
   /**
-   * Given some {@link ClassElement}, this method finds and returns the {@link ExecutableElement} of
+   * Given some [ClassElement], this method finds and returns the [ExecutableElement] of
    * the passed name in the class element. Static members, members in super types and members not
    * accessible from the current library are not considered.
    * @param classElt the class element to query
    * @param memberName the name of the member to lookup in the class
-   * @return the found {@link ExecutableElement}, or {@code null} if no such member was found
+   * @return the found [ExecutableElement], or `null` if no such member was found
    */
   ExecutableElement lookupMemberInClass(ClassElement classElt, String memberName) {
     List<MethodElement> methods = classElt.methods;
     for (MethodElement method in methods) {
       if (memberName == method.name && method.isAccessibleIn(_library) && !method.isStatic()) {
         return method;
       }
     }
     List<PropertyAccessorElement> accessors = classElt.accessors;
     for (PropertyAccessorElement accessor in accessors) {
       if (memberName == accessor.name && accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
         return accessor;
       }
     }
     return null;
   }
 
   /**
    * Record the passed map with the set of all members (methods, getters and setters) in the class
    * into the passed map.
-   * @param map some non-{@code null}
+   * @param map some non-`null`
    * @param classElt the class element that will be recorded into the passed map
    */
   void recordMapWithClassMembers(Map<String, ExecutableElement> map, ClassElement classElt) {
     List<MethodElement> methods = classElt.methods;
     for (MethodElement method in methods) {
       if (method.isAccessibleIn(_library) && !method.isStatic()) {
         map[method.name] = method;
       }
     }
     List<PropertyAccessorElement> accessors = classElt.accessors;
     for (PropertyAccessorElement accessor in accessors) {
       if (accessor.isAccessibleIn(_library) && !accessor.isStatic()) {
         map[accessor.name] = accessor;
       }
     }
   }
 
   /**
    * This method is used to report errors on when they are found computing inheritance information.
-   * See {@link ErrorVerifier#checkForInconsistentMethodInheritance()} to see where these generated
+   * See [ErrorVerifier#checkForInconsistentMethodInheritance] to see where these generated
    * error codes are reported back into the analysis engine.
    * @param classElt the location of the source for which the exception occurred
    * @param offset the offset of the location of the error
    * @param length the length of the location of the error
    * @param errorCode the error code to be associated with this error
    * @param arguments the arguments used to build the error message
    */
   void reportError(ClassElement classElt, int offset, int length, ErrorCode errorCode, List<Object> arguments) {
     Set<AnalysisError> errorSet = _errorsInClassElement[classElt];
     if (errorSet == null) {
       errorSet = new Set<AnalysisError>();
       _errorsInClassElement[classElt] = errorSet;
     }
     javaSetAdd(errorSet, new AnalysisError.con2(classElt.source, offset, length, errorCode, arguments));
   }
 }
 /**
- * Instances of the class {@code Library} represent the data about a single library during the
+ * Instances of the class `Library` represent the data about a single library during the
  * resolution of some (possibly different) library. They are not intended to be used except during
  * the resolution process.
  * @coverage dart.engine.resolver
  */
 class Library {
 
   /**
    * The analysis context in which this library is being analyzed.
    */
   InternalAnalysisContext _analysisContext;
@@ skipping 102 matching lines @@
 
   /**
    * Return the AST structure associated with the defining compilation unit for this library.
    * @return the AST structure associated with the defining compilation unit for this library
    * @throws AnalysisException if an AST structure could not be created for the defining compilation
    * unit
    */
   CompilationUnit get definingCompilationUnit => getAST(librarySource);
 
   /**
-   * Return {@code true} if this library explicitly imports core.
-   * @return {@code true} if this library explicitly imports core
+   * Return `true` if this library explicitly imports core.
+   * @return `true` if this library explicitly imports core
    */
   bool get explicitlyImportsCore => _explicitlyImportsCore;
 
   /**
    * Return the library exported by the given directive.
    * @param directive the directive that exports the library to be returned
    * @return the library exported by the given directive
    */
   Library getExport(ExportDirective directive) => _exportedLibraries[directive];
 
@@ skipping 74 matching lines @@
   }
 
   /**
    * Return the source specifying the defining compilation unit of this library.
    * @return the source specifying the defining compilation unit of this library
    */
   Source get librarySource => _librarySource;
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
-   * library, or {@code null} if the URI is not valid. If the URI is not valid, report the error.
+   * library, or `null` if the URI is not valid. If the URI is not valid, report the error.
    * @param directive the directive which URI should be resolved
    * @return the result of resolving the URI against the URI of the library
    */
   Source getSource(UriBasedDirective directive) {
     StringLiteral uriLiteral = directive.uri;
     if (uriLiteral is StringInterpolation) {
       _errorListener.onError(new AnalysisError.con2(_librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION, []));
       return null;
     }
     String uriContent = uriLiteral.stringValue.trim();
@@ skipping 20 matching lines @@
    * Set the AST structure associated with the defining compilation unit for this library to the
    * given AST structure.
    * @param unit the AST structure associated with the defining compilation unit for this library
    */
   void set definingCompilationUnit(CompilationUnit unit) {
     _astMap[librarySource] = unit;
   }
 
   /**
    * Set whether this library explicitly imports core to match the given value.
-   * @param explicitlyImportsCore {@code true} if this library explicitly imports core
+   * @param explicitlyImportsCore `true` if this library explicitly imports core
    */
   void set explicitlyImportsCore(bool explicitlyImportsCore2) {
     this._explicitlyImportsCore = explicitlyImportsCore2;
   }
 
   /**
    * Set the library element representing this library to the given library element.
    * @param libraryElement the library element representing this library
    */
   void set libraryElement(LibraryElementImpl libraryElement2) {
     this._libraryElement = libraryElement2;
     if (_inheritanceManager != null) {
       _inheritanceManager.libraryElement = libraryElement2;
     }
   }
   String toString() => _librarySource.shortName;
 
   /**
-   * Return the result of resolving the given URI against the URI of the library, or {@code null} if
+   * Return the result of resolving the given URI against the URI of the library, or `null` if
    * the URI is not valid.
    * @param uri the URI to be resolved
    * @return the result of resolving the given URI against the URI of the library
    */
   Source getSource2(String uri) {
     if (uri == null) {
       return null;
     }
     return _analysisContext.sourceFactory.resolveUri(_librarySource, uri);
   }
 }
 /**
- * Instances of the class {@code LibraryElementBuilder} build an element model for a single library.
+ * Instances of the class `LibraryElementBuilder` build an element model for a single library.
  * @coverage dart.engine.resolver
  */
 class LibraryElementBuilder {
 
   /**
    * The analysis context in which the element model will be built.
    */
   InternalAnalysisContext _analysisContext;
 
   /**
@@ skipping 98 matching lines @@
         if (!accessor.isSynthetic() && accessor.correspondingGetter == null) {
           setters.add(accessor);
         }
       }
     }
   }
 
   /**
    * Search the top-level functions defined in the given compilation unit for the entry point.
    * @param element the compilation unit to be searched
-   * @return the entry point that was found, or {@code null} if the compilation unit does not define
+   * @return the entry point that was found, or `null` if the compilation unit does not define
    * an entry point
    */
   FunctionElement findEntryPoint(CompilationUnitElementImpl element) {
     for (FunctionElement function in element.functions) {
       if (function.name == _ENTRY_POINT_NAME) {
         return function;
       }
     }
     return null;
   }
 
   /**
-   * Return the name of the library that the given part is declared to be a part of, or {@code null}if the part does not contain a part-of directive.
+   * Return the name of the library that the given part is declared to be a part of, or `null`if the part does not contain a part-of directive.
    * @param library the library containing the part
    * @param partSource the source representing the part
    * @param directivesToResolve a list of directives that should be resolved to the library being
    * built
    * @return the name of the library that the given part is declared to be a part of
    */
   String getPartLibraryName(Library library, Source partSource, List<Directive> directivesToResolve) {
     try {
       CompilationUnit partUnit = library.getAST(partSource);
       for (Directive directive in partUnit.directives) {
@@ skipping 27 matching lines @@
       PropertyAccessorElement getter = getters[setter.displayName];
       if (getter != null) {
         PropertyInducingElementImpl variable = getter.variable as PropertyInducingElementImpl;
         variable.setter = setter;
         ((setter as PropertyAccessorElementImpl)).variable = variable;
       }
     }
   }
 }
 /**
- * Instances of the class {@code LibraryResolver} are used to resolve one or more mutually dependent
+ * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
  * libraries within a single context.
  * @coverage dart.engine.resolver
  */
 class LibraryResolver {
 
   /**
    * The analysis context in which the libraries are being analyzed.
    */
   InternalAnalysisContext _analysisContext;
 
   /**
    * The listener to which analysis errors will be reported, this error listener is either
-   * references {@link #recordingErrorListener}, or it unions the passed{@link AnalysisErrorListener} with the {@link #recordingErrorListener}.
+   * references [recordingErrorListener], or it unions the passed[AnalysisErrorListener] with the [recordingErrorListener].
    */
   RecordingErrorListener _errorListener;
 
   /**
    * A source object representing the core library (dart:core).
    */
   Source _coreLibrarySource;
 
   /**
    * The object representing the core library.
@@ skipping 42 matching lines @@
    * @return an array containing the libraries that were resolved
    */
   Set<Library> get resolvedLibraries => _librariesInCycles;
 
   /**
    * Resolve the library specified by the given source in the given context. The library is assumed
    * to be embedded in the given source.
    * @param librarySource the source specifying the defining compilation unit of the library to be
    * resolved
    * @param unit the compilation unit representing the embedded library
-   * @param fullAnalysis {@code true} if a full analysis should be performed
+   * @param fullAnalysis `true` if a full analysis should be performed
    * @return the element representing the resolved library
    * @throws AnalysisException if the library could not be resolved for some reason
    */
   LibraryElement resolveEmbeddedLibrary(Source librarySource, CompilationUnit unit, bool fullAnalysis) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.LibraryResolver.resolveEmbeddedLibrary");
     try {
       instrumentation.metric("fullAnalysis", fullAnalysis);
       instrumentation.data3("fullName", librarySource.fullName);
       Library targetLibrary = createLibrary2(librarySource, unit);
       _coreLibrary = _libraryMap[_coreLibrarySource];
@@ skipping 23 matching lines @@
         instrumentation.metric3("runAdditionalAnalyses", "complete");
       }
       return targetLibrary.libraryElement;
     } finally {
       instrumentation.log();
     }
   }
 
   /**
    * Resolve the library specified by the given source in the given context.
-   * <p>
+   *
    * Note that because Dart allows circular imports between libraries, it is possible that more than
    * one library will need to be resolved. In such cases the error listener can receive errors from
    * multiple libraries.
    * @param librarySource the source specifying the defining compilation unit of the library to be
    * resolved
-   * @param fullAnalysis {@code true} if a full analysis should be performed
+   * @param fullAnalysis `true` if a full analysis should be performed
    * @return the element representing the resolved library
    * @throws AnalysisException if the library could not be resolved for some reason
    */
   LibraryElement resolveLibrary(Source librarySource, bool fullAnalysis) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.LibraryResolver.resolveLibrary");
     try {
       instrumentation.metric("fullAnalysis", fullAnalysis);
       instrumentation.data3("fullName", librarySource.fullName);
       Library targetLibrary = createLibrary(librarySource);
       _coreLibrary = _libraryMap[_coreLibrarySource];
@@ skipping 102 matching lines @@
       } else {
         ShowElementCombinatorImpl show = new ShowElementCombinatorImpl();
         show.shownNames = getIdentifiers(((combinator as ShowCombinator)).shownNames);
         combinators.add(show);
       }
     }
     return new List.from(combinators);
   }
 
   /**
-   * Every library now has a corresponding {@link LibraryElement}, so it is now possible to resolve
+   * Every library now has a corresponding [LibraryElement], so it is now possible to resolve
    * the import and export directives.
    * @throws AnalysisException if the defining compilation unit for any of the libraries could not
    * be accessed
    */
   void buildDirectiveModels() {
     for (Library library in _librariesInCycles) {
       Map<String, PrefixElementImpl> nameToPrefixMap = new Map<String, PrefixElementImpl>();
       List<ImportElement> imports = new List<ImportElement>();
       List<ExportElement> exports = new List<ExportElement>();
       for (Directive directive in library.definingCompilationUnit.directives) {
@@ skipping 73 matching lines @@
         TypeResolverVisitor visitor = new TypeResolverVisitor.con1(library, source, _typeProvider);
         library.getAST(source).accept(visitor);
       }
     }
   }
 
   /**
    * Compute a dependency map of libraries reachable from the given library. A dependency map is a
    * table that maps individual libraries to a list of the libraries that either import or export
    * those libraries.
-   * <p>
+   *
    * This map is used to compute all of the libraries involved in a cycle that include the root
    * library. Given that we only add libraries that are reachable from the root library, when we
    * work backward we are guaranteed to only get libraries in the cycle.
    * @param library the library currently being added to the dependency map
    */
   Map<Library, List<Library>> computeDependencyMap(Library library) {
     Map<Library, List<Library>> dependencyMap = new Map<Library, List<Library>>();
     addToDependencyMap(library, dependencyMap, new Set<Library>());
     return dependencyMap;
   }
 
   /**
    * Return a collection containing all of the libraries reachable from the given library that are
    * contained in a cycle that includes the given library.
    * @param library the library that must be included in any cycles whose members are to be returned
    * @return all of the libraries referenced by the given library that have a circular reference
    * back to the given library
    */
   Set<Library> computeLibrariesInCycles(Library library) {
     Map<Library, List<Library>> dependencyMap = computeDependencyMap(library);
     Set<Library> librariesInCycle = new Set<Library>();
     addLibrariesInCycle(library, librariesInCycle, dependencyMap);
     return librariesInCycle;
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
-   * class {@link Library} to represent them, and record the references in the library objects.
+   * class [Library] to represent them, and record the references in the library objects.
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
   void computeLibraryDependencies(Library library) {
     bool explicitlyImportsCore = false;
     CompilationUnit unit = library.definingCompilationUnit;
     for (Directive directive in unit.directives) {
       if (directive is ImportDirective) {
         ImportDirective importDirective = directive as ImportDirective;
         Source importedSource = library.getSource(importDirective);
@@ skipping 72 matching lines @@
    */
   Library createLibrary2(Source librarySource, CompilationUnit unit) {
     Library library = new Library(_analysisContext, _errorListener, librarySource);
     library.definingCompilationUnit = unit;
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation unit
-   * with the given source. Return the library object that was created, or {@code null} if the
+   * with the given source. Return the library object that was created, or `null` if the
    * source is not valid.
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
    */
   Library createLibraryOrNull(Source librarySource) {
     if (!librarySource.exists()) {
       return null;
     }
     Library library = new Library(_analysisContext, _errorListener, librarySource);
     try {
       library.definingCompilationUnit;
     } on AnalysisException catch (exception) {
       return null;
     }
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
-   * Return {@code true} if and only if the passed {@link CompilationUnit} has a part-of directive.
-   * @param node the {@link CompilationUnit} to test
-   * @return {@code true} if and only if the passed {@link CompilationUnit} has a part-of directive
+   * Return `true` if and only if the passed [CompilationUnit] has a part-of directive.
+   * @param node the [CompilationUnit] to test
+   * @return `true` if and only if the passed [CompilationUnit] has a part-of directive
    */
   bool doesCompilationUnitHavePartOfDirective(CompilationUnit node) {
     NodeList<Directive> directives = node.directives;
     for (Directive directive in directives) {
       if (directive is PartOfDirective) {
         return true;
       }
     }
     return false;
   }
@@ skipping 50 matching lines @@
    * the library cannot be analyzed
    */
   void resolveReferencesAndTypes2(Library library) {
     for (Source source in library.compilationUnitSources) {
       ResolverVisitor visitor = new ResolverVisitor.con1(library, source, _typeProvider);
       library.getAST(source).accept(visitor);
     }
   }
 
   /**
-   * Run additional analyses, such as the {@link ConstantVerifier} and {@link ErrorVerifier}analysis in the current cycle.
+   * Run additional analyses, such as the [ConstantVerifier] and [ErrorVerifier]analysis in the current cycle.
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    * the library cannot be analyzed
    */
   void runAdditionalAnalyses() {
     for (Library library in _librariesInCycles) {
       runAdditionalAnalyses2(library);
     }
   }
 
   /**
-   * Run additional analyses, such as the {@link ConstantVerifier} and {@link ErrorVerifier}analysis in the given library.
+   * Run additional analyses, such as the [ConstantVerifier] and [ErrorVerifier]analysis in the given library.
    * @param library the library to have the extra analyses processes run
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    * the library cannot be analyzed
    */
   void runAdditionalAnalyses2(Library library) {
     for (Source source in library.compilationUnitSources) {
       ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
       CompilationUnit unit = library.getAST(source);
+      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _typeProvider);
+      unit.accept(constantVerifier);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, library.libraryElement, _typeProvider, library.inheritanceManager);
       unit.accept(errorVerifier);
-      unit.accept(new PubVerifier(_analysisContext, errorReporter));
-      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _typeProvider);
-      unit.accept(constantVerifier);
     }
   }
 }
 /**
- * Instances of the class {@code ResolverVisitor} are used to resolve the nodes within a single
+ * Instances of the class `ResolverVisitor` are used to resolve the nodes within a single
  * compilation unit.
  * @coverage dart.engine.resolver
  */
 class ResolverVisitor extends ScopedVisitor {
 
   /**
    * The object used to resolve the element associated with the current node.
    */
   ElementResolver _elementResolver;
 
   /**
    * The object used to compute the type associated with the current node.
    */
   StaticTypeAnalyzer _typeAnalyzer;
 
   /**
-   * The class element representing the class containing the current node, or {@code null} if the
+   * The class element representing the class containing the current node, or `null` if the
    * current node is not contained in a class.
    */
   ClassElement _enclosingClass = null;
 
   /**
-   * The element representing the function containing the current node, or {@code null} if the
+   * The element representing the function containing the current node, or `null` if the
    * current node is not contained in a function.
    */
   ExecutableElement _enclosingFunction = null;
 
   /**
    * The object keeping track of which elements have had their types overridden.
    */
   TypeOverrideManager _overrideManager = new TypeOverrideManager();
 
   /**
    * 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
    */
   ResolverVisitor.con1(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider) {
-    _jtd_constructor_273_impl(library, source, typeProvider);
+    _jtd_constructor_274_impl(library, source, typeProvider);
   }
-  _jtd_constructor_273_impl(Library library, Source source, TypeProvider typeProvider) {
+  _jtd_constructor_274_impl(Library library, Source source, TypeProvider typeProvider) {
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param definingLibrary the element for the library containing the compilation unit being
    * visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    * during resolution
    */
   ResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) : super.con2(definingLibrary, source, typeProvider, errorListener) {
-    _jtd_constructor_274_impl(definingLibrary, source, typeProvider, errorListener);
+    _jtd_constructor_275_impl(definingLibrary, source, typeProvider, errorListener);
   }
-  _jtd_constructor_274_impl(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
+  _jtd_constructor_275_impl(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   /**
    * Return the object keeping track of which elements have had their types overridden.
    * @return the object keeping track of which elements have had their types overridden
    */
   TypeOverrideManager get overrideManager => _overrideManager;
   Object visitAsExpression(AsExpression node) {
@@ skipping 358 matching lines @@
       } finally {
         _overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   /**
-   * Return the class element representing the class containing the current node, or {@code null} if
+   * Return the class element representing the class containing the current node, or `null` if
    * the current node is not contained in a class.
    * @return the class element representing the class containing the current node
    */
   ClassElement get enclosingClass => _enclosingClass;
 
   /**
-   * Return the element representing the function containing the current node, or {@code null} if
+   * Return the element representing the function containing the current node, or `null` if
    * the current node is not contained in a function.
    * @return the element representing the function containing the current node
    */
   ExecutableElement get enclosingFunction => _enclosingFunction;
 
   /**
-   * Return the element associated with the given expression whose type can be overridden, or{@code null} if there is no element whose type can be overridden.
+   * Return the element associated with the given expression whose type can be overridden, or`null` if there is no element whose type can be overridden.
    * @param expression the expression with which the element is associated
    * @return the element associated with the given expression
    */
   VariableElement getOverridableElement(Expression expression) {
     Element element = null;
     if (expression is SimpleIdentifier) {
       element = ((expression as SimpleIdentifier)).element;
     } else if (expression is PrefixedIdentifier) {
       element = ((expression as PrefixedIdentifier)).element;
     } else if (expression is PropertyAccess) {
@@ skipping 78 matching lines @@
       } else if (element is ParameterElement) {
         bestType = ((element as ParameterElement)).type;
       }
     }
     return bestType;
   }
 
   /**
    * The given expression is the expression used to compute the iterator for a for-each statement.
    * Attempt to compute the type of objects that will be assigned to the loop variable and return
-   * that type. Return {@code null} if the type could not be determined.
+   * that type. Return `null` if the type could not be determined.
    * @param iterator the iterator for a for-each statement
    * @return the type of objects that will be assigned to the loop variable
    */
   Type2 getIteratorElementType(Expression iteratorExpression) {
     Type2 expressionType = iteratorExpression.staticType;
     if (expressionType is InterfaceType) {
       PropertyAccessorElement iterator = ((expressionType as InterfaceType)).lookUpGetter("iterator", definingLibrary);
       if (iterator == null) {
         return null;
       }
       Type2 iteratorType = iterator.type.returnType;
       if (iteratorType is InterfaceType) {
         PropertyAccessorElement current = ((iteratorType as InterfaceType)).lookUpGetter("current", definingLibrary);
         if (current == null) {
           return null;
         }
         return current.type.returnType;
       }
     }
     return null;
   }
 
   /**
-   * Return {@code true} if the given expression terminates abruptly (that is, if any expression
+   * Return `true` if the given expression terminates abruptly (that is, if any expression
    * following the given expression will not be reached).
    * @param expression the expression being tested
-   * @return {@code true} if the given expression terminates abruptly
+   * @return `true` if the given expression terminates abruptly
    */
   bool isAbruptTermination(Expression expression2) {
     while (expression2 is ParenthesizedExpression) {
       expression2 = ((expression2 as ParenthesizedExpression)).expression;
     }
     return expression2 is ThrowExpression || expression2 is RethrowExpression;
   }
 
   /**
-   * Return {@code true} if the given statement terminates abruptly (that is, if any statement
+   * Return `true` if the given statement terminates abruptly (that is, if any statement
    * following the given statement will not be reached).
    * @param statement the statement being tested
-   * @return {@code true} if the given statement terminates abruptly
+   * @return `true` if the given statement terminates abruptly
    */
   bool isAbruptTermination2(Statement statement) {
     if (statement is ReturnStatement || statement is BreakStatement || statement is ContinueStatement) {
       return true;
     } else if (statement is ExpressionStatement) {
       return isAbruptTermination(((statement as ExpressionStatement)).expression);
     } else if (statement is Block) {
       NodeList<Statement> statements = ((statement as Block)).statements;
       int size = statements.length;
       if (size == 0) {
@@ skipping 76 matching lines @@
   get labelScope_J2DAccessor => _labelScope;
   set labelScope_J2DAccessor(__v) => _labelScope = __v;
   get nameScope_J2DAccessor => _nameScope;
   set nameScope_J2DAccessor(__v) => _nameScope = __v;
   get typeAnalyzer_J2DAccessor => _typeAnalyzer;
   set typeAnalyzer_J2DAccessor(__v) => _typeAnalyzer = __v;
   get enclosingClass_J2DAccessor => _enclosingClass;
   set enclosingClass_J2DAccessor(__v) => _enclosingClass = __v;
 }
 /**
- * The abstract class {@code ScopedVisitor} maintains name and label scopes as an AST structure is
+ * The abstract class `ScopedVisitor` maintains name and label scopes as an AST structure is
  * being visited.
  * @coverage dart.engine.resolver
  */
 abstract class ScopedVisitor extends GeneralizingASTVisitor<Object> {
 
   /**
    * The element for the library containing the compilation unit being visited.
    */
   LibraryElement _definingLibrary;
 
@@ skipping 11 matching lines @@
    * The scope used to resolve identifiers.
    */
   Scope _nameScope;
 
   /**
    * The object used to access the types from the core library.
    */
   TypeProvider _typeProvider;
 
   /**
-   * The scope used to resolve labels for {@code break} and {@code continue} statements, or{@code null} if no labels have been defined in the current context.
+   * The scope used to resolve labels for `break` and `continue` statements, or`null` if no labels have been defined in the current context.
    */
   LabelScope _labelScope;
 
   /**
    * 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
    */
   ScopedVisitor.con1(Library library, Source source2, TypeProvider typeProvider2) {
-    _jtd_constructor_275_impl(library, source2, typeProvider2);
+    _jtd_constructor_276_impl(library, source2, typeProvider2);
   }
-  _jtd_constructor_275_impl(Library library, Source source2, TypeProvider typeProvider2) {
+  _jtd_constructor_276_impl(Library library, Source source2, TypeProvider typeProvider2) {
     this._definingLibrary = library.libraryElement;
     this._source = source2;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
     this._nameScope = libraryScope;
     this._typeProvider = typeProvider2;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param definingLibrary the element for the library containing the compilation unit being
    * visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    * during resolution
    */
   ScopedVisitor.con2(LibraryElement definingLibrary2, Source source2, TypeProvider typeProvider2, AnalysisErrorListener errorListener2) {
-    _jtd_constructor_276_impl(definingLibrary2, source2, typeProvider2, errorListener2);
+    _jtd_constructor_277_impl(definingLibrary2, source2, typeProvider2, errorListener2);
   }
-  _jtd_constructor_276_impl(LibraryElement definingLibrary2, Source source2, TypeProvider typeProvider2, AnalysisErrorListener errorListener2) {
+  _jtd_constructor_277_impl(LibraryElement definingLibrary2, Source source2, TypeProvider typeProvider2, AnalysisErrorListener errorListener2) {
     this._definingLibrary = definingLibrary2;
     this._source = source2;
     this._errorListener = errorListener2;
     this._nameScope = new LibraryScope(definingLibrary2, errorListener2);
     this._typeProvider = typeProvider2;
   }
 
   /**
    * Return the library element for the library containing the compilation unit being resolved.
    * @return the library element for the library containing the compilation unit being resolved
@@ skipping 312 matching lines @@
     for (Label label in labels) {
       SimpleIdentifier labelNameNode = label.label;
       String labelName = labelNameNode.name;
       LabelElement labelElement = labelNameNode.element as LabelElement;
       _labelScope = new LabelScope.con2(_labelScope, labelName, labelElement);
     }
     return outerScope;
   }
 }
 /**
- * Instances of the class {@code StaticTypeAnalyzer} perform two type-related tasks. First, they
+ * Instances of the class `StaticTypeAnalyzer` perform two type-related tasks. First, they
  * compute the static type of every expression. Second, they look for any static type errors or
  * warnings that might need to be generated. The requirements for the type analyzer are:
  * <ol>
- * <li>Every element that refers to types should be fully populated.
- * <li>Every node representing an expression should be resolved to the Type of the expression.</li>
+ * * Every element that refers to types should be fully populated.
+ * * Every node representing an expression should be resolved to the Type of the expression.
  * </ol>
  * @coverage dart.engine.resolver
  */
 class StaticTypeAnalyzer extends SimpleASTVisitor<Object> {
 
   /**
    * Create a table mapping HTML tag names to the names of the classes (in 'dart:html') that
    * implement those tags.
    * @return the table that was created
    */
@@ skipping 69 matching lines @@
    * The object providing access to the types defined by the language.
    */
   TypeProvider _typeProvider;
 
   /**
    * The type representing the type 'dynamic'.
    */
   Type2 _dynamicType;
 
   /**
-   * The type representing the class containing the nodes being analyzed, or {@code null} if the
+   * The type representing the class containing the nodes being analyzed, or `null` if the
    * nodes are not within a class.
    */
   InterfaceType _thisType;
 
   /**
    * The object keeping track of which elements have had their types overridden.
    */
   TypeOverrideManager _overrideManager;
 
   /**
@@ skipping 15 matching lines @@
 
   /**
    * Set the type of the class being analyzed to the given type.
    * @param thisType the type representing the class containing the nodes being analyzed
    */
   void set thisType(InterfaceType thisType2) {
     this._thisType = thisType2;
   }
 
   /**
-   * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is{@code String}.</blockquote>
+   * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is`String`.</blockquote>
    */
   Object visitAdjacentStrings(AdjacentStrings node) {
     recordStaticType(node, _typeProvider.stringType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.33: <blockquote>The static type of an argument definition
-   * test is {@code bool}.</blockquote>
+   * test is `bool`.</blockquote>
    */
   Object visitArgumentDefinitionTest(ArgumentDefinitionTest node) {
     recordStaticType(node, _typeProvider.boolType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.32: <blockquote>... the cast expression <i>e as T</i> ...
-   * <p>
+   *
    * It is a static warning if <i>T</i> does not denote a type available in the current lexical
    * scope.
-   * <p>
+   *
    * The static type of a cast expression <i>e as T</i> is <i>T</i>.</blockquote>
    */
   Object visitAsExpression(AsExpression node) {
     recordStaticType(node, getType2(node.type));
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.18: <blockquote>... an assignment <i>a</i> of the form <i>v
    * = e</i> ...
-   * <p>
+   *
    * It is a static type warning if the static type of <i>e</i> may not be assigned to the static
    * type of <i>v</i>.
-   * <p>
+   *
    * The static type of the expression <i>v = e</i> is the static type of <i>e</i>.
-   * <p>
+   *
    * ... an assignment of the form <i>C.v = e</i> ...
-   * <p>
+   *
    * It is a static type warning if the static type of <i>e</i> may not be assigned to the static
    * type of <i>C.v</i>.
-   * <p>
+   *
    * The static type of the expression <i>C.v = e</i> is the static type of <i>e</i>.
-   * <p>
+   *
    * ... an assignment of the form <i>e<sub>1</sub>.v = e<sub>2</sub></i> ...
-   * <p>
+   *
    * Let <i>T</i> be the static type of <i>e<sub>1</sub></i>. It is a static type warning if
    * <i>T</i> does not have an accessible instance setter named <i>v=</i>. It is a static type
    * warning if the static type of <i>e<sub>2</sub></i> may not be assigned to <i>T</i>.
-   * <p>
+   *
    * The static type of the expression <i>e<sub>1</sub>.v = e<sub>2</sub></i> is the static type of
    * <i>e<sub>2</sub></i>.
-   * <p>
+   *
    * ... an assignment of the form <i>e<sub>1</sub>\[e<sub>2</sub>\] = e<sub>3</sub></i> ...
-   * <p>
+   *
    * The static type of the expression <i>e<sub>1</sub>\[e<sub>2</sub>\] = e<sub>3</sub></i> is the
    * static type of <i>e<sub>3</sub></i>.
-   * <p>
+   *
    * A compound assignment of the form <i>v op= e</i> is equivalent to <i>v = v op e</i>. A compound
    * assignment of the form <i>C.v op= e</i> is equivalent to <i>C.v = C.v op e</i>. A compound
    * assignment of the form <i>e<sub>1</sub>.v op= e<sub>2</sub></i> is equivalent to <i>((x) => x.v
    * = x.v op e<sub>2</sub>)(e<sub>1</sub>)</i> where <i>x</i> is a variable that is not used in
    * <i>e<sub>2</sub></i>. A compound assignment of the form <i>e<sub>1</sub>\[e<sub>2</sub>\] op=
    * e<sub>3</sub></i> is equivalent to <i>((a, i) => a\[i\] = a\[i\] op e<sub>3</sub>)(e<sub>1</sub>,
    * e<sub>2</sub>)</i> where <i>a</i> and <i>i</i> are a variables that are not used in
    * <i>e<sub>3</sub></i>.</blockquote>
    */
   Object visitAssignmentExpression(AssignmentExpression node) {
@@ skipping 24 matching lines @@
         if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
           recordPropagatedType(node, propagatedType);
         }
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.20: <blockquote>The static type of a logical boolean
-   * expression is {@code bool}.</blockquote>
-   * <p>
+   * expression is `bool`.</blockquote>
+   *
    * The Dart Language Specification, 12.21:<blockquote>A bitwise expression of the form
    * <i>e<sub>1</sub> op e<sub>2</sub></i> is equivalent to the method invocation
    * <i>e<sub>1</sub>.op(e<sub>2</sub>)</i>. A bitwise expression of the form <i>super op
    * e<sub>2</sub></i> is equivalent to the method invocation
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
-   * <p>
+   *
    * The Dart Language Specification, 12.22: <blockquote>The static type of an equality expression
-   * is {@code bool}.</blockquote>
-   * <p>
+   * is `bool`.</blockquote>
+   *
    * The Dart Language Specification, 12.23: <blockquote>A relational expression of the form
    * <i>e<sub>1</sub> op e<sub>2</sub></i> is equivalent to the method invocation
    * <i>e<sub>1</sub>.op(e<sub>2</sub>)</i>. A relational expression of the form <i>super op
    * e<sub>2</sub></i> is equivalent to the method invocation
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
-   * <p>
+   *
    * The Dart Language Specification, 12.24: <blockquote>A shift expression of the form
    * <i>e<sub>1</sub> op e<sub>2</sub></i> is equivalent to the method invocation
    * <i>e<sub>1</sub>.op(e<sub>2</sub>)</i>. A shift expression of the form <i>super op
    * e<sub>2</sub></i> is equivalent to the method invocation
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
-   * <p>
+   *
    * The Dart Language Specification, 12.25: <blockquote>An additive expression of the form
    * <i>e<sub>1</sub> op e<sub>2</sub></i> is equivalent to the method invocation
    * <i>e<sub>1</sub>.op(e<sub>2</sub>)</i>. An additive expression of the form <i>super op
    * e<sub>2</sub></i> is equivalent to the method invocation
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
-   * <p>
+   *
    * The Dart Language Specification, 12.26: <blockquote>A multiplicative expression of the form
    * <i>e<sub>1</sub> op e<sub>2</sub></i> is equivalent to the method invocation
    * <i>e<sub>1</sub>.op(e<sub>2</sub>)</i>. A multiplicative expression of the form <i>super op
    * e<sub>2</sub></i> is equivalent to the method invocation
    * <i>super.op(e<sub>2</sub>)</i>.</blockquote>
    */
   Object visitBinaryExpression(BinaryExpression node) {
     ExecutableElement staticMethodElement = node.staticElement;
     Type2 staticType = computeReturnType(staticMethodElement);
     staticType = refineBinaryExpressionType(node, staticType);
@@ skipping 24 matching lines @@
    */
   Object visitCascadeExpression(CascadeExpression node) {
     recordStaticType(node, getStaticType(node.target));
     recordPropagatedType(node, getPropagatedType(node.target));
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.19: <blockquote> ... a conditional expression <i>c</i> of
    * the form <i>e<sub>1</sub> ? e<sub>2</sub> : e<sub>3</sub></i> ...
-   * <p>
-   * It is a static type warning if the type of e<sub>1</sub> may not be assigned to {@code bool}.
-   * <p>
+   *
+   * It is a static type warning if the type of e<sub>1</sub> may not be assigned to `bool`.
+   *
    * The static type of <i>c</i> is the least upper bound of the static type of <i>e<sub>2</sub></i>
    * and the static type of <i>e<sub>3</sub></i>.</blockquote>
    */
   Object visitConditionalExpression(ConditionalExpression node) {
     Type2 staticThenType = getStaticType(node.thenExpression);
     Type2 staticElseType = getStaticType(node.elseExpression);
     if (staticThenType == null) {
       staticThenType = _dynamicType;
     }
     if (staticElseType == null) {
@@ skipping 24 matching lines @@
   /**
    * The Dart Language Specification, 12.3: <blockquote>The static type of a literal double is
    * double.</blockquote>
    */
   Object visitDoubleLiteral(DoubleLiteral node) {
     recordStaticType(node, _typeProvider.doubleType);
     return null;
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     FunctionExpression function = node.functionExpression;
-    FunctionTypeImpl functionType = node.element.type as FunctionTypeImpl;
-    setTypeInformation(functionType, computeReturnType2(node), function.parameters);
+    ExecutableElementImpl functionElement = node.element as ExecutableElementImpl;
+    functionElement.returnType = computeReturnType2(node);
+    FunctionTypeImpl functionType = functionElement.type as FunctionTypeImpl;
+    setTypeInformation(functionType, function.parameters);
     recordStaticType(function, functionType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.9: <blockquote>The static type of a function literal of the
    * form <i>(T<sub>1</sub> a<sub>1</sub>, &hellip;, T<sub>n</sub> a<sub>n</sub>, \[T<sub>n+1</sub>
    * x<sub>n+1</sub> = d1, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub> = dk\]) => e</i> is
    * <i>(T<sub>1</sub>, &hellip;, Tn, \[T<sub>n+1</sub> x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub>
    * x<sub>n+k</sub>\]) &rarr; T<sub>0</sub></i>, where <i>T<sub>0</sub></i> is the static type of
    * <i>e</i>. In any case where <i>T<sub>i</sub>, 1 &lt;= i &lt;= n</i>, is not specified, it is
    * considered to have been specified as dynamic.
-   * <p>
+   *
    * The static type of a function literal of the form <i>(T<sub>1</sub> a<sub>1</sub>, &hellip;,
    * T<sub>n</sub> a<sub>n</sub>, {T<sub>n+1</sub> x<sub>n+1</sub> : d1, &hellip;, T<sub>n+k</sub>
    * x<sub>n+k</sub> : dk}) => e</i> is <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, {T<sub>n+1</sub>
    * x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub>}) &rarr; T<sub>0</sub></i>, where
    * <i>T<sub>0</sub></i> is the static type of <i>e</i>. In any case where <i>T<sub>i</sub>, 1
    * &lt;= i &lt;= n</i>, is not specified, it is considered to have been specified as dynamic.
-   * <p>
+   *
    * The static type of a function literal of the form <i>(T<sub>1</sub> a<sub>1</sub>, &hellip;,
    * T<sub>n</sub> a<sub>n</sub>, \[T<sub>n+1</sub> x<sub>n+1</sub> = d1, &hellip;, T<sub>n+k</sub>
    * x<sub>n+k</sub> = dk\]) {s}</i> is <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, \[T<sub>n+1</sub>
    * x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub>\]) &rarr; dynamic</i>. In any case
    * where <i>T<sub>i</sub>, 1 &lt;= i &lt;= n</i>, is not specified, it is considered to have been
    * specified as dynamic.
-   * <p>
+   *
    * The static type of a function literal of the form <i>(T<sub>1</sub> a<sub>1</sub>, &hellip;,
    * T<sub>n</sub> a<sub>n</sub>, {T<sub>n+1</sub> x<sub>n+1</sub> : d1, &hellip;, T<sub>n+k</sub>
    * x<sub>n+k</sub> : dk}) {s}</i> is <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>, {T<sub>n+1</sub>
    * x<sub>n+1</sub>, &hellip;, T<sub>n+k</sub> x<sub>n+k</sub>}) &rarr; dynamic</i>. In any case
    * where <i>T<sub>i</sub>, 1 &lt;= i &lt;= n</i>, is not specified, it is considered to have been
    * specified as dynamic.</blockquote>
    */
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is FunctionDeclaration) {
       return null;
     }
+    ExecutableElementImpl functionElement = node.element as ExecutableElementImpl;
+    functionElement.returnType = computeReturnType3(node);
     FunctionTypeImpl functionType = node.element.type as FunctionTypeImpl;
-    setTypeInformation(functionType, computeReturnType3(node), node.parameters);
+    setTypeInformation(functionType, node.parameters);
     recordStaticType(node, functionType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.14.4: <blockquote>A function expression invocation <i>i</i>
    * has the form <i>e<sub>f</sub>(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>:
    * a<sub>n+1</sub>, &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>, where <i>e<sub>f</sub></i> is
    * an expression.
-   * <p>
+   *
    * It is a static type warning if the static type <i>F</i> of <i>e<sub>f</sub></i> may not be
    * assigned to a function type.
-   * <p>
+   *
    * If <i>F</i> is not a function type, the static type of <i>i</i> is dynamic. Otherwise the
    * static type of <i>i</i> is the declared return type of <i>F</i>.</blockquote>
    */
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     ExecutableElement staticMethodElement = node.staticElement;
     Type2 staticType = computeReturnType(staticMethodElement);
     recordStaticType(node, staticType);
     ExecutableElement propagatedMethodElement = node.element;
     Type2 propagatedType = computeReturnType(propagatedMethodElement);
     if (staticType == null) {
@@ skipping 33 matching lines @@
         }
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.11.1: <blockquote>The static type of a new expression of
    * either the form <i>new T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the form <i>new
    * T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>.</blockquote>
-   * <p>
+   *
    * The Dart Language Specification, 12.11.2: <blockquote>The static type of a constant object
    * expression of either the form <i>const T.id(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> or the
    * form <i>const T(a<sub>1</sub>, &hellip;, a<sub>n</sub>)</i> is <i>T</i>. </blockquote>
    */
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     recordStaticType(node, node.constructorName.type.type);
     ConstructorElement element = node.element;
     if (element != null && "Element" == element.enclosingElement.name && "tag" == element.name) {
       LibraryElement library = element.library;
       if (isHtmlLibrary(library)) {
         Type2 returnType = getFirstArgumentAsType2(library, node.argumentList, _HTML_ELEMENT_TO_CLASS_MAP);
         if (returnType != null) {
           recordPropagatedType(node, returnType);
         }
       }
     }
     return null;
   }
 
   /**
-   * The Dart Language Specification, 12.3: <blockquote>The static type of an integer literal is{@code int}.</blockquote>
+   * The Dart Language Specification, 12.3: <blockquote>The static type of an integer literal is`int`.</blockquote>
    */
   Object visitIntegerLiteral(IntegerLiteral node) {
     recordStaticType(node, _typeProvider.intType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.31: <blockquote>It is a static warning if <i>T</i> does not
    * denote a type available in the current lexical scope.
-   * <p>
-   * The static type of an is-expression is {@code bool}.</blockquote>
+   *
+   * The static type of an is-expression is `bool`.</blockquote>
    */
   Object visitIsExpression(IsExpression node) {
     recordStaticType(node, _typeProvider.boolType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.6: <blockquote>The static type of a list literal of the
    * form <i><b>const</b> &lt;E&gt;\[e<sub>1</sub>, &hellip;, e<sub>n</sub>\]</i> or the form
-   * <i>&lt;E&gt;\[e<sub>1</sub>, &hellip;, e<sub>n</sub>\]</i> is {@code List&lt;E&gt;}. The static
+   * <i>&lt;E&gt;\[e<sub>1</sub>, &hellip;, e<sub>n</sub>\]</i> is `List&lt;E&gt;`. The static
    * type a list literal of the form <i><b>const</b> \[e<sub>1</sub>, &hellip;, e<sub>n</sub>\]</i> or
-   * the form <i>\[e<sub>1</sub>, &hellip;, e<sub>n</sub>\]</i> is {@code List&lt;dynamic&gt;}.</blockquote>
+   * the form <i>\[e<sub>1</sub>, &hellip;, e<sub>n</sub>\]</i> is `List&lt;dynamic&gt;`.</blockquote>
    */
   Object visitListLiteral(ListLiteral node) {
     Type2 staticType = _dynamicType;
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
       NodeList<TypeName> arguments = typeArguments.arguments;
       if (arguments != null && arguments.length == 1) {
         TypeName argumentTypeName = arguments[0];
         Type2 argumentType = getType2(argumentTypeName);
         if (argumentType != null) {
@@ skipping 21 matching lines @@
         recordPropagatedType(node, _typeProvider.listType.substitute5(<Type2> [propagatedType]));
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.7: <blockquote>The static type of a map literal of the form
    * <i><b>const</b> &lt;String, V&gt; {k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> or the form <i>&lt;String, V&gt; {k<sub>1</sub>:e<sub>1</sub>,
-   * &hellip;, k<sub>n</sub>:e<sub>n</sub>}</i> is {@code Map&lt;String, V&gt;}. The static type a
+   * &hellip;, k<sub>n</sub>:e<sub>n</sub>}</i> is `Map&lt;String, V&gt;`. The static type a
    * map literal of the form <i><b>const</b> {k<sub>1</sub>:e<sub>1</sub>, &hellip;,
    * k<sub>n</sub>:e<sub>n</sub>}</i> or the form <i>{k<sub>1</sub>:e<sub>1</sub>, &hellip;,
-   * k<sub>n</sub>:e<sub>n</sub>}</i> is {@code Map&lt;String, dynamic&gt;}.
-   * <p>
+   * k<sub>n</sub>:e<sub>n</sub>}</i> is `Map&lt;String, dynamic&gt;`.
+   *
    * It is a compile-time error if the first type argument to a map literal is not
    * <i>String</i>.</blockquote>
    */
   Object visitMapLiteral(MapLiteral node) {
     Type2 staticKeyType = _dynamicType;
     Type2 staticValueType = _dynamicType;
     TypeArgumentList typeArguments = node.typeArguments;
     if (typeArguments != null) {
       NodeList<TypeName> arguments = typeArguments.arguments;
       if (arguments != null && arguments.length == 2) {
@@ skipping 49 matching lines @@
         recordPropagatedType(node, _typeProvider.mapType.substitute5(<Type2> [propagatedKeyType, propagatedValueType]));
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.15.1: <blockquote>An ordinary method invocation <i>i</i>
    * has the form <i>o.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</sub>,
    * &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>.
-   * <p>
+   *
    * Let <i>T</i> be the static type of <i>o</i>. It is a static type warning if <i>T</i> does not
    * have an accessible instance member named <i>m</i>. If <i>T.m</i> exists, it is a static warning
    * if the type <i>F</i> of <i>T.m</i> may not be assigned to a function type.
-   * <p>
+   *
    * If <i>T.m</i> does not exist, or if <i>F</i> is not a function type, the static type of
    * <i>i</i> is dynamic. Otherwise the static type of <i>i</i> is the declared return type of
    * <i>F</i>.</blockquote>
-   * <p>
+   *
    * The Dart Language Specification, 11.15.3: <blockquote>A static method invocation <i>i</i> has
    * the form <i>C.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</sub>,
    * &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>.
-   * <p>
+   *
    * It is a static type warning if the type <i>F</i> of <i>C.m</i> may not be assigned to a
    * function type.
-   * <p>
+   *
    * If <i>F</i> is not a function type, or if <i>C.m</i> does not exist, the static type of i is
    * dynamic. Otherwise the static type of <i>i</i> is the declared return type of
    * <i>F</i>.</blockquote>
-   * <p>
+   *
    * The Dart Language Specification, 11.15.4: <blockquote>A super method invocation <i>i</i> has
    * the form <i>super.m(a<sub>1</sub>, &hellip;, a<sub>n</sub>, x<sub>n+1</sub>: a<sub>n+1</sub>,
    * &hellip;, x<sub>n+k</sub>: a<sub>n+k</sub>)</i>.
-   * <p>
+   *
    * It is a static type warning if <i>S</i> does not have an accessible instance member named m. If
    * <i>S.m</i> exists, it is a static warning if the type <i>F</i> of <i>S.m</i> may not be
    * assigned to a function type.
-   * <p>
+   *
    * If <i>S.m</i> does not exist, or if <i>F</i> is not a function type, the static type of
    * <i>i</i> is dynamic. Otherwise the static type of <i>i</i> is the declared return type of
    * <i>F</i>.</blockquote>
    */
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier methodNameNode = node.methodName;
     Element staticMethodElement = methodNameNode.staticElement;
     if (staticMethodElement == null) {
       staticMethodElement = methodNameNode.element;
     }
@@ skipping 68 matching lines @@
     return null;
   }
   Object visitNamedExpression(NamedExpression node) {
     Expression expression = node.expression;
     recordStaticType(node, getStaticType(expression));
     recordPropagatedType(node, getPropagatedType(expression));
     return null;
   }
 
   /**
-   * The Dart Language Specification, 12.2: <blockquote>The static type of {@code null} is bottom.
+   * The Dart Language Specification, 12.2: <blockquote>The static type of `null` is bottom.
    * </blockquote>
    */
   Object visitNullLiteral(NullLiteral node) {
     recordStaticType(node, _typeProvider.bottomType);
     return null;
   }
   Object visitParenthesizedExpression(ParenthesizedExpression node) {
     Expression expression = node.expression;
     recordStaticType(node, getStaticType(expression));
     recordPropagatedType(node, getPropagatedType(expression));
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.28: <blockquote>A postfix expression of the form
    * <i>v++</i>, where <i>v</i> is an identifier, is equivalent to <i>(){var r = v; v = r + 1;
    * return r}()</i>.
-   * <p>
+   *
    * A postfix expression of the form <i>C.v++</i> is equivalent to <i>(){var r = C.v; C.v = r + 1;
    * return r}()</i>.
-   * <p>
+   *
    * A postfix expression of the form <i>e1.v++</i> is equivalent to <i>(x){var r = x.v; x.v = r +
    * 1; return r}(e1)</i>.
-   * <p>
+   *
    * A postfix expression of the form <i>e1\[e2\]++</i> is equivalent to <i>(a, i){var r = a\[i\]; a\[i\]
    * = r + 1; return r}(e1, e2)</i>
-   * <p>
+   *
    * A postfix expression of the form <i>v--</i>, where <i>v</i> is an identifier, is equivalent to
    * <i>(){var r = v; v = r - 1; return r}()</i>.
-   * <p>
+   *
    * A postfix expression of the form <i>C.v--</i> is equivalent to <i>(){var r = C.v; C.v = r - 1;
    * return r}()</i>.
-   * <p>
+   *
    * A postfix expression of the form <i>e1.v--</i> is equivalent to <i>(x){var r = x.v; x.v = r -
    * 1; return r}(e1)</i>.
-   * <p>
+   *
    * A postfix expression of the form <i>e1\[e2\]--</i> is equivalent to <i>(a, i){var r = a\[i\]; a\[i\]
    * = r - 1; return r}(e1, e2)</i></blockquote>
    */
   Object visitPostfixExpression(PostfixExpression node) {
     Expression operand = node.operand;
     Type2 staticType = getStaticType(operand);
     sc.TokenType operator = node.operator.type;
     if (identical(operator, sc.TokenType.MINUS_MINUS) || identical(operator, sc.TokenType.PLUS_PLUS)) {
       Type2 intType = _typeProvider.intType;
       if (identical(getStaticType(node.operand), intType)) {
         staticType = intType;
       }
     }
     recordStaticType(node, staticType);
     recordPropagatedType(node, getPropagatedType(operand));
     return null;
   }
 
   /**
-   * See {@link #visitSimpleIdentifier(SimpleIdentifier)}.
+   * See [visitSimpleIdentifier].
    */
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixedIdentifier = node.identifier;
     Element element = prefixedIdentifier.element;
     Type2 staticType = _dynamicType;
     if (element is ClassElement) {
       if (isNotTypeLiteral(node)) {
         staticType = ((element as ClassElement)).type;
       } else {
         staticType = _typeProvider.typeType;
@@ skipping 48 matching lines @@
         }
       }
     }
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.13: <blockquote> Property extraction allows for a member of
    * an object to be concisely extracted from the object. If <i>o</i> is an object, and if <i>m</i>
    * is the name of a method member of <i>o</i>, then
-   * <ul>
-   * <li><i>o.m</i> is defined to be equivalent to: <i>(r<sub>1</sub>, &hellip;, r<sub>n</sub>,
+   *
+   * * <i>o.m</i> is defined to be equivalent to: <i>(r<sub>1</sub>, &hellip;, r<sub>n</sub>,
    * {p<sub>1</sub> : d<sub>1</sub>, &hellip;, p<sub>k</sub> : d<sub>k</sub>}){return
    * o.m(r<sub>1</sub>, &hellip;, r<sub>n</sub>, p<sub>1</sub>: p<sub>1</sub>, &hellip;,
    * p<sub>k</sub>: p<sub>k</sub>);}</i> if <i>m</i> has required parameters <i>r<sub>1</sub>,
    * &hellip;, r<sub>n</sub></i>, and named parameters <i>p<sub>1</sub> &hellip; p<sub>k</sub></i>
-   * with defaults <i>d<sub>1</sub>, &hellip;, d<sub>k</sub></i>.</li>
-   * <li><i>(r<sub>1</sub>, &hellip;, r<sub>n</sub>, \[p<sub>1</sub> = d<sub>1</sub>, &hellip;,
+   * with defaults <i>d<sub>1</sub>, &hellip;, d<sub>k</sub></i>.
+   * * <i>(r<sub>1</sub>, &hellip;, r<sub>n</sub>, \[p<sub>1</sub> = d<sub>1</sub>, &hellip;,
    * p<sub>k</sub> = d<sub>k</sub>\]){return o.m(r<sub>1</sub>, &hellip;, r<sub>n</sub>,
    * p<sub>1</sub>, &hellip;, p<sub>k</sub>);}</i> if <i>m</i> has required parameters
    * <i>r<sub>1</sub>, &hellip;, r<sub>n</sub></i>, and optional positional parameters
    * <i>p<sub>1</sub> &hellip; p<sub>k</sub></i> with defaults <i>d<sub>1</sub>, &hellip;,
-   * d<sub>k</sub></i>.</li>
-   * </ul>
+   * d<sub>k</sub></i>.
+   *
    * Otherwise, if <i>m</i> is the name of a getter member of <i>o</i> (declared implicitly or
    * explicitly) then <i>o.m</i> evaluates to the result of invoking the getter. </blockquote>
-   * <p>
+   *
    * The Dart Language Specification, 12.17: <blockquote> ... a getter invocation <i>i</i> of the
    * form <i>e.m</i> ...
-   * <p>
+   *
    * Let <i>T</i> be the static type of <i>e</i>. It is a static type warning if <i>T</i> does not
    * have a getter named <i>m</i>.
-   * <p>
+   *
    * The static type of <i>i</i> is the declared return type of <i>T.m</i>, if <i>T.m</i> exists;
    * otherwise the static type of <i>i</i> is dynamic.
-   * <p>
+   *
    * ... a getter invocation <i>i</i> of the form <i>C.m</i> ...
-   * <p>
+   *
    * It is a static warning if there is no class <i>C</i> in the enclosing lexical scope of
    * <i>i</i>, or if <i>C</i> does not declare, implicitly or explicitly, a getter named <i>m</i>.
-   * <p>
+   *
    * The static type of <i>i</i> is the declared return type of <i>C.m</i> if it exists or dynamic
    * otherwise.
-   * <p>
+   *
    * ... a top-level getter invocation <i>i</i> of the form <i>m</i>, where <i>m</i> is an
    * identifier ...
-   * <p>
+   *
    * The static type of <i>i</i> is the declared return type of <i>m</i>.</blockquote>
    */
   Object visitPropertyAccess(PropertyAccess node) {
     SimpleIdentifier propertyName = node.propertyName;
     Element element = propertyName.element;
     Type2 staticType = _dynamicType;
     if (element is MethodElement) {
       staticType = ((element as MethodElement)).type;
     } else if (element is PropertyAccessorElement) {
       staticType = getType((element as PropertyAccessorElement), node.target != null ? getStaticType(node.target) : null);
@@ skipping 13 matching lines @@
    * bottom.</blockquote>
    */
   Object visitRethrowExpression(RethrowExpression node) {
     recordStaticType(node, _typeProvider.bottomType);
     return null;
   }
 
   /**
    * The Dart Language Specification, 12.30: <blockquote>Evaluation of an identifier expression
    * <i>e</i> of the form <i>id</i> proceeds as follows:
-   * <p>
+   *
    * Let <i>d</i> be the innermost declaration in the enclosing lexical scope whose name is
    * <i>id</i>. If no such declaration exists in the lexical scope, let <i>d</i> be the declaration
    * of the inherited member named <i>id</i> if it exists.
-   * <ul>
-   * <li>If <i>d</i> is a class or type alias <i>T</i>, the value of <i>e</i> is the unique instance
-   * of class {@code Type} reifying <i>T</i>.
-   * <li>If <i>d</i> is a type parameter <i>T</i>, then the value of <i>e</i> is the value of the
+   *
+   * * If <i>d</i> is a class or type alias <i>T</i>, the value of <i>e</i> is the unique instance
+   * of class `Type` reifying <i>T</i>.
+   * * If <i>d</i> is a type parameter <i>T</i>, then the value of <i>e</i> is the value of the
    * actual type argument corresponding to <i>T</i> that was passed to the generative constructor
    * that created the current binding of this. We are assured that this is well defined, because if
    * we were in a static member the reference to <i>T</i> would be a compile-time error.
-   * <li>If <i>d</i> is a library variable then:
-   * <ul>
-   * <li>If <i>d</i> is of one of the forms <i>var v = e<sub>i</sub>;</i>, <i>T v =
+   * * If <i>d</i> is a library variable then:
+   *
+   * * If <i>d</i> is of one of the forms <i>var v = e<sub>i</sub>;</i>, <i>T v =
    * e<sub>i</sub>;</i>, <i>final v = e<sub>i</sub>;</i>, <i>final T v = e<sub>i</sub>;</i>, and no
    * value has yet been stored into <i>v</i> then the initializer expression <i>e<sub>i</sub></i> is
    * evaluated. If, during the evaluation of <i>e<sub>i</sub></i>, the getter for <i>v</i> is
    * referenced, a CyclicInitializationError is thrown. If the evaluation succeeded yielding an
    * object <i>o</i>, let <i>r = o</i>, otherwise let <i>r = null</i>. In any case, <i>r</i> is
    * stored into <i>v</i>. The value of <i>e</i> is <i>r</i>.
-   * <li>If <i>d</i> is of one of the forms <i>const v = e;</i> or <i>const T v = e;</i> the result
+   * * If <i>d</i> is of one of the forms <i>const v = e;</i> or <i>const T v = e;</i> the result
    * of the getter is the value of the compile time constant <i>e</i>. Otherwise
-   * <li><i>e</i> evaluates to the current binding of <i>id</i>.
-   * </ul>
-   * <li>If <i>d</i> is a local variable or formal parameter then <i>e</i> evaluates to the current
+   * * <i>e</i> evaluates to the current binding of <i>id</i>.
+   *
+   * * If <i>d</i> is a local variable or formal parameter then <i>e</i> evaluates to the current
    * binding of <i>id</i>.
-   * <li>If <i>d</i> is a static method, top level function or local function then <i>e</i>
+   * * If <i>d</i> is a static method, top level function or local function then <i>e</i>
    * evaluates to the function defined by <i>d</i>.
-   * <li>If <i>d</i> is the declaration of a static variable or static getter declared in class
+   * * If <i>d</i> is the declaration of a static variable or static getter declared in class
    * <i>C</i>, then <i>e</i> is equivalent to the getter invocation <i>C.id</i>.
-   * <li>If <i>d</i> is the declaration of a top level getter, then <i>e</i> is equivalent to the
+   * * If <i>d</i> is the declaration of a top level getter, then <i>e</i> is equivalent to the
    * getter invocation <i>id</i>.
-   * <li>Otherwise, if <i>e</i> occurs inside a top level or static function (be it function,
+   * * Otherwise, if <i>e</i> occurs inside a top level or static function (be it function,
    * method, getter, or setter) or variable initializer, evaluation of e causes a NoSuchMethodError
    * to be thrown.
-   * <li>Otherwise <i>e</i> is equivalent to the property extraction <i>this.id</i>.
-   * </ul>
+   * * Otherwise <i>e</i> is equivalent to the property extraction <i>this.id</i>.
+   *
    * </blockquote>
    */
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.element;
     Type2 staticType = _dynamicType;
     if (element is ClassElement) {
       if (isNotTypeLiteral(node)) {
         staticType = ((element as ClassElement)).type;
       } else {
         staticType = _typeProvider.typeType;
@@ skipping 17 matching lines @@
     }
     recordStaticType(node, staticType);
     Type2 propagatedType = _overrideManager.getType(element);
     if (propagatedType != null && propagatedType.isMoreSpecificThan(staticType)) {
       recordPropagatedType(node, propagatedType);
     }
     return null;
   }
 
   /**
-   * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is{@code String}.</blockquote>
+   * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is`String`.</blockquote>
    */
   Object visitSimpleStringLiteral(SimpleStringLiteral node) {
     recordStaticType(node, _typeProvider.stringType);
     return null;
   }
 
   /**
-   * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is{@code String}.</blockquote>
+   * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is`String`.</blockquote>
    */
   Object visitStringInterpolation(StringInterpolation node) {
     recordStaticType(node, _typeProvider.stringType);
     return null;
   }
   Object visitSuperExpression(SuperExpression node) {
     if (_thisType == null) {
       recordStaticType(node, _dynamicType);
     } else {
       recordStaticType(node, _thisType);
     }
     return null;
   }
 
   /**
-   * The Dart Language Specification, 12.10: <blockquote>The static type of {@code this} is the
+   * The Dart Language Specification, 12.10: <blockquote>The static type of `this` is the
    * interface of the immediately enclosing class.</blockquote>
    */
   Object visitThisExpression(ThisExpression node) {
     if (_thisType == null) {
       recordStaticType(node, _dynamicType);
     } else {
       recordStaticType(node, _thisType);
     }
     return null;
   }
@@ skipping 72 matching lines @@
       Type2 variableType = ((element as VariableElement)).type;
       if (variableType is FunctionType) {
         return ((variableType as FunctionType)).returnType;
       }
     }
     return _dynamicType;
   }
 
   /**
    * Given a function declaration, compute the return type of the function. The return type of
-   * functions with a block body is {@code dynamicType}, with an expression body it is the type of
+   * functions with a block body is `dynamicType`, with an expression body it is the type of
    * the expression.
    * @param node the function expression whose return type is to be computed
    * @return the return type that was computed
    */
   Type2 computeReturnType2(FunctionDeclaration node) {
     TypeName returnType = node.returnType;
     if (returnType == null) {
       return _dynamicType;
     }
     return returnType.type;
   }
 
   /**
    * Given a function expression, compute the return type of the function. The return type of
-   * functions with a block body is {@code dynamicType}, with an expression body it is the type of
+   * functions with a block body is `dynamicType`, with an expression body it is the type of
    * the expression.
    * @param node the function expression whose return type is to be computed
    * @return the return type that was computed
    */
   Type2 computeReturnType3(FunctionExpression node) {
     FunctionBody body = node.body;
     if (body is ExpressionFunctionBody) {
       return getStaticType(((body as ExpressionFunctionBody)).expression);
     }
     return _dynamicType;
@@ skipping 112 matching lines @@
     Type2 type = expression.staticType;
     if (type == null) {
       return _dynamicType;
     }
     return type;
   }
 
   /**
    * Return the type that should be recorded for a node that resolved to the given accessor.
    * @param accessor the accessor that the node resolved to
-   * @param context if the accessor element has context \[by being the RHS of a{@link PrefixedIdentifier} or {@link PropertyAccess}\], and the return type of the
+   * @param context if the accessor element has context \[by being the RHS of a[PrefixedIdentifier] or [PropertyAccess]\], and the return type of the
    * accessor is a parameter type, then the type of the LHS can be used to get more
    * specific type information
    * @return the type that should be recorded for a node that resolved to the given accessor
    */
   Type2 getType(PropertyAccessorElement accessor, Type2 context) {
     FunctionType functionType = accessor.type;
     if (functionType == null) {
       return _dynamicType;
     }
     if (accessor.isSetter()) {
@@ skipping 33 matching lines @@
    */
   Type2 getType2(TypeName typeName) {
     Type2 type = typeName.type;
     if (type == null) {
       return _dynamicType;
     }
     return type;
   }
 
   /**
-   * Return {@code true} if the given library is the 'dart:html' library.
+   * Return `true` if the given library is the 'dart:html' library.
    * @param library the library being tested
-   * @return {@code true} if the library is 'dart:html'
+   * @return `true` if the library is 'dart:html'
    */
   bool isHtmlLibrary(LibraryElement library) => library.name == "dart.dom.html";
 
   /**
-   * Return {@code true} if the given node is not a type literal.
+   * Return `true` if the given node is not a type literal.
    * @param node the node being tested
-   * @return {@code true} if the given node is not a type literal
+   * @return `true` if the given node is not a type literal
    */
   bool isNotTypeLiteral(Identifier node) {
     ASTNode parent = node.parent;
     return parent is TypeName || (parent is PrefixedIdentifier && (parent.parent is TypeName || identical(((parent as PrefixedIdentifier)).prefix, node))) || (parent is PropertyAccess && identical(((parent as PropertyAccess)).target, node)) || (parent is MethodInvocation && identical(node, ((parent as MethodInvocation)).target));
   }
 
   /**
    * Record that the propagated type of the given node is the given type.
    * @param expression the node whose type is to be recorded
    * @param type the propagated type of the node
@@ skipping 40 matching lines @@
         staticType = intType;
       }
     }
     return staticType;
   }
 
   /**
    * Set the return type and parameter type information for the given function type based on the
    * given return type and parameter elements.
    * @param functionType the function type to be filled in
-   * @param returnType the return type of the function, or {@code null} if no type was declared
    * @param parameters the elements representing the parameters to the function
    */
-  void setTypeInformation(FunctionTypeImpl functionType, Type2 returnType2, FormalParameterList parameterList) {
+  void setTypeInformation(FunctionTypeImpl functionType, FormalParameterList parameterList) {
     List<Type2> normalParameterTypes = new List<Type2>();
     List<Type2> optionalParameterTypes = new List<Type2>();
     LinkedHashMap<String, Type2> namedParameterTypes = new LinkedHashMap<String, Type2>();
     if (parameterList != null) {
       for (ParameterElement parameter in parameterList.elements) {
         while (true) {
           if (parameter.parameterKind == ParameterKind.REQUIRED) {
             normalParameterTypes.add(parameter.type);
           } else if (parameter.parameterKind == ParameterKind.POSITIONAL) {
             optionalParameterTypes.add(parameter.type);
           } else if (parameter.parameterKind == ParameterKind.NAMED) {
             namedParameterTypes[parameter.name] = parameter.type;
           }
           break;
         }
       }
     }
     functionType.normalParameterTypes = new List.from(normalParameterTypes);
     functionType.optionalParameterTypes = new List.from(optionalParameterTypes);
     functionType.namedParameterTypes = namedParameterTypes;
-    functionType.returnType = returnType2;
   }
   get thisType_J2DAccessor => _thisType;
   set thisType_J2DAccessor(__v) => _thisType = __v;
 }
 /**
- * Instances of the class {@code TypeOverrideManager} manage the ability to override the type of an
+ * Instances of the class `TypeOverrideManager` manage the ability to override the type of an
  * element within a given context.
  */
 class TypeOverrideManager {
 
   /**
-   * The current override scope, or {@code null} if no scope has been entered.
+   * The current override scope, or `null` if no scope has been entered.
    */
   TypeOverrideManager_TypeOverrideScope _currentScope;
 
   /**
    * Apply a set of overrides that were previously captured.
    * @param overrides the overrides to be applied
    */
   void applyOverrides(Map<Element, Type2> overrides) {
     if (_currentScope == null) {
       throw new IllegalStateException("Cannot apply overrides without a scope");
@@ skipping 37 matching lines @@
    * Exit the current override scope.
    */
   void exitScope() {
     if (_currentScope == null) {
       throw new IllegalStateException("No scope to exit");
     }
     _currentScope = _currentScope._outerScope;
   }
 
   /**
-   * Return the overridden type of the given element, or {@code null} if the type of the element has
+   * Return the overridden type of the given element, or `null` if the type of the element has
    * not been overridden.
    * @param element the element whose type might have been overridden
    * @return the overridden type of the given element
    */
   Type2 getType(Element element) {
     if (_currentScope == null) {
       return null;
     }
     return _currentScope.getType(element);
   }
 
   /**
    * Set the overridden type of the given element to the given type
    * @param element the element whose type might have been overridden
    * @param type the overridden type of the given element
    */
   void setType(Element element, Type2 type) {
     if (_currentScope == null) {
       throw new IllegalStateException("Cannot override without a scope");
     }
     _currentScope.setType(element, type);
   }
 }
 /**
- * Instances of the class {@code TypeOverrideScope} represent a scope in which the types of
+ * Instances of the class `TypeOverrideScope` represent a scope in which the types of
  * elements can be overridden.
  */
 class TypeOverrideManager_TypeOverrideScope {
 
   /**
    * The outer scope in which types might be overridden.
    */
   TypeOverrideManager_TypeOverrideScope _outerScope;
 
   /**
@@ skipping 42 matching lines @@
           if (type != null) {
             overrides[element] = type;
           }
         }
       }
     }
     return overrides;
   }
 
   /**
-   * Return the overridden type of the given element, or {@code null} if the type of the element
+   * Return the overridden type of the given element, or `null` if the type of the element
    * has not been overridden.
    * @param element the element whose type might have been overridden
    * @return the overridden type of the given element
    */
   Type2 getType(Element element) {
     Type2 type = _overridenTypes[element];
     if (type == null && element is PropertyAccessorElement) {
       type = _overridenTypes[((element as PropertyAccessorElement)).variable];
     }
     if (type != null) {
       return type;
     } else if (_outerScope != null) {
       return _outerScope.getType(element);
     }
     return null;
   }
 
   /**
    * Set the overridden type of the given element to the given type
    * @param element the element whose type might have been overridden
    * @param type the overridden type of the given element
    */
   void setType(Element element, Type2 type) {
     _overridenTypes[element] = type;
   }
 }
 /**
- * The interface {@code TypeProvider} defines the behavior of objects that provide access to types
+ * The interface `TypeProvider` defines the behavior of objects that provide access to types
  * defined by the language.
  * @coverage dart.engine.resolver
  */
 abstract class TypeProvider {
 
   /**
    * Return the type representing the built-in type 'bool'.
    * @return the type representing the built-in type 'bool'
    */
   InterfaceType get boolType;
@@ skipping 64 matching lines @@
    */
   InterfaceType get stringType;
 
   /**
    * Return the type representing the built-in type 'Type'.
    * @return the type representing the built-in type 'Type'
    */
   InterfaceType get typeType;
 }
 /**
- * Instances of the class {@code TypeProviderImpl} provide access to types defined by the language
+ * Instances of the class `TypeProviderImpl` provide access to types defined by the language
  * by looking for those types in the element model for the core library.
  * @coverage dart.engine.resolver
  */
 class TypeProviderImpl implements TypeProvider {
 
   /**
    * The type representing the built-in type 'bool'.
    */
   InterfaceType _boolType;
 
@@ skipping 72 matching lines @@
   InterfaceType get intType => _intType;
   InterfaceType get listType => _listType;
   InterfaceType get mapType => _mapType;
   InterfaceType get numType => _numType;
   InterfaceType get objectType => _objectType;
   InterfaceType get stackTraceType => _stackTraceType;
   InterfaceType get stringType => _stringType;
   InterfaceType get typeType => _typeType;
 
   /**
-   * Return the type with the given name from the given namespace, or {@code null} if there is no
+   * Return the type with the given name from the given namespace, or `null` if there is no
    * class with the given name.
    * @param namespace the namespace in which to search for the given name
    * @param typeName the name of the type being searched for
    * @return the type that was found
    */
   InterfaceType getType(Namespace namespace, String typeName) {
     Element element = namespace.get(typeName);
     if (element == null) {
       AnalysisEngine.instance.logger.logInformation("No definition of type ${typeName}");
       return null;
@@ skipping 16 matching lines @@
     _listType = getType(namespace, "List");
     _mapType = getType(namespace, "Map");
     _numType = getType(namespace, "num");
     _objectType = getType(namespace, "Object");
     _stackTraceType = getType(namespace, "StackTrace");
     _stringType = getType(namespace, "String");
     _typeType = getType(namespace, "Type");
   }
 }
 /**
- * Instances of the class {@code TypeResolverVisitor} are used to resolve the types associated with
+ * Instances of the class `TypeResolverVisitor` are used to resolve the types associated with
  * the elements in the element model. This includes the types of superclasses, mixins, interfaces,
  * fields, methods, parameters, and local variables. As a side-effect, this also finishes building
  * the type hierarchy.
  * @coverage dart.engine.resolver
  */
 class TypeResolverVisitor extends ScopedVisitor {
 
   /**
    * The type representing the type 'dynamic'.
    */
   Type2 _dynamicType;
 
   /**
    * The flag specifying if currently visited class references 'super' expression.
    */
   bool _hasReferenceToSuper = false;
 
   /**
    * 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
    */
   TypeResolverVisitor.con1(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider) {
-    _jtd_constructor_281_impl(library, source, typeProvider);
+    _jtd_constructor_282_impl(library, source, typeProvider);
   }
-  _jtd_constructor_281_impl(Library library, Source source, TypeProvider typeProvider) {
+  _jtd_constructor_282_impl(Library library, Source source, TypeProvider typeProvider) {
     _dynamicType = typeProvider.dynamicType;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    * @param definingLibrary the element for the library containing the compilation unit being
    * visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    * during resolution
    */
   TypeResolverVisitor.con2(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) : super.con2(definingLibrary, source, typeProvider, errorListener) {
-    _jtd_constructor_282_impl(definingLibrary, source, typeProvider, errorListener);
+    _jtd_constructor_283_impl(definingLibrary, source, typeProvider, errorListener);
   }
-  _jtd_constructor_282_impl(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
+  _jtd_constructor_283_impl(LibraryElement definingLibrary, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
     _dynamicType = typeProvider.dynamicType;
   }
   Object visitCatchClause(CatchClause node) {
     super.visitCatchClause(node);
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
       TypeName exceptionTypeName = node.exceptionType;
       Type2 exceptionType;
       if (exceptionTypeName == null) {
         exceptionType = typeProvider.objectType;
@@ skipping 48 matching lines @@
     }
     if (classElement != null && superclassType != null) {
       classElement.supertype = superclassType;
     }
     resolve(classElement, node.withClause, node.implementsClause);
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     super.visitConstructorDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
+    ClassElement definingClass = element.enclosingElement as ClassElement;
+    element.returnType = definingClass.type;
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
-    setTypeInformation(type, null, element.parameters);
-    type.returnType = ((element.enclosingElement as ClassElement)).type;
+    type.typeArguments = definingClass.type.typeArguments;
+    setTypeInformation(type, element.parameters);
     element.type = type;
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     Type2 declaredType;
     TypeName typeName = node.type;
     if (typeName == null) {
       declaredType = _dynamicType;
     } else {
@@ skipping 20 matching lines @@
         type = getType3(typeName);
       }
       parameter.type = type;
     } else {
     }
     return null;
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     super.visitFunctionDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
+    element.returnType = computeReturnType(node.returnType);
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
-    setTypeInformation(type, node.returnType, element.parameters);
+    ClassElement definingClass = element.getAncestor(ClassElement);
+    if (definingClass != null) {
+      type.typeArguments = definingClass.type.typeArguments;
+    }
+    setTypeInformation(type, element.parameters);
     element.type = type;
     return null;
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     super.visitFunctionTypeAlias(node);
     FunctionTypeAliasElementImpl element = node.element as FunctionTypeAliasElementImpl;
+    element.returnType = computeReturnType(node.returnType);
     FunctionTypeImpl type = element.type as FunctionTypeImpl;
-    setTypeInformation(type, node.returnType, element.parameters);
+    setTypeInformation(type, element.parameters);
     return null;
   }
   Object visitFunctionTypedFormalParameter(FunctionTypedFormalParameter node) {
     super.visitFunctionTypedFormalParameter(node);
     ParameterElementImpl element = node.identifier.element as ParameterElementImpl;
-    AnonymousFunctionTypeImpl type = new AnonymousFunctionTypeImpl();
     List<ParameterElement> parameters = getElements(node.parameters);
-    setTypeInformation(type, node.returnType, parameters);
-    type.baseParameters = parameters;
+    FunctionTypeAliasElementImpl aliasElement = new FunctionTypeAliasElementImpl(null);
+    aliasElement.synthetic = true;
+    aliasElement.parameters = parameters;
+    aliasElement.returnType = computeReturnType(node.returnType);
+    FunctionTypeImpl type = new FunctionTypeImpl.con2(aliasElement);
+    ClassElement definingClass = element.getAncestor(ClassElement);
+    if (definingClass != null) {
+      aliasElement.typeVariables = definingClass.typeVariables;
+      type.typeArguments = definingClass.type.typeArguments;
+    } else {
+      FunctionTypeAliasElement alias = element.getAncestor(FunctionTypeAliasElement);
+      if (alias != null) {
+        aliasElement.typeVariables = alias.typeVariables;
+        type.typeArguments = alias.type.typeArguments;
+      } else {
+        type.typeArguments = TypeVariableTypeImpl.EMPTY_ARRAY;
+      }
+    }
+    setTypeInformation(type, parameters);
     element.type = type;
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
     super.visitMethodDeclaration(node);
     ExecutableElementImpl element = node.element as ExecutableElementImpl;
+    element.returnType = computeReturnType(node.returnType);
     FunctionTypeImpl type = new FunctionTypeImpl.con1(element);
-    setTypeInformation(type, node.returnType, element.parameters);
+    ClassElement definingClass = element.getAncestor(ClassElement);
+    if (definingClass != null) {
+      type.typeArguments = definingClass.type.typeArguments;
+    }
+    setTypeInformation(type, element.parameters);
     element.type = type;
     if (element is PropertyAccessorElement) {
       PropertyAccessorElement accessor = element as PropertyAccessorElement;
       PropertyInducingElementImpl variable = accessor.variable as PropertyInducingElementImpl;
       if (accessor.isGetter()) {
         variable.type = type.returnType;
       } else if (variable.type == null) {
         List<Type2> parameterTypes = type.normalParameterTypes;
         if (parameterTypes != null && parameterTypes.length > 0) {
           variable.type = parameterTypes[0];
@@ skipping 196 matching lines @@
       declaredType = _dynamicType;
     } else {
       declaredType = getType3(typeName);
     }
     Element element = node.name.element;
     if (element is VariableElement) {
       ((element as VariableElementImpl)).type = declaredType;
       if (element is PropertyInducingElement) {
         PropertyInducingElement variableElement = element as PropertyInducingElement;
         PropertyAccessorElementImpl getter = variableElement.getter as PropertyAccessorElementImpl;
+        getter.returnType = declaredType;
         FunctionTypeImpl getterType = new FunctionTypeImpl.con1(getter);
-        getterType.returnType = declaredType;
+        ClassElement definingClass = element.getAncestor(ClassElement);
+        if (definingClass != null) {
+          getterType.typeArguments = definingClass.type.typeArguments;
+        }
         getter.type = getterType;
         PropertyAccessorElementImpl setter = variableElement.setter as PropertyAccessorElementImpl;
         if (setter != null) {
+          setter.returnType = VoidTypeImpl.instance;
           FunctionTypeImpl setterType = new FunctionTypeImpl.con1(setter);
-          setterType.returnType = VoidTypeImpl.instance;
+          if (definingClass != null) {
+            setterType.typeArguments = definingClass.type.typeArguments;
+          }
           setterType.normalParameterTypes = <Type2> [declaredType];
           setter.type = setterType;
         }
       }
     } else {
     }
     return null;
   }
 
   /**
+   * Given a type name representing the return type of a function, compute the return type of the
+   * function.
+   * @param returnType the type name representing the return type of the function
+   * @return the return type that was computed
+   */
+  Type2 computeReturnType(TypeName returnType) {
+    if (returnType == null) {
+      return _dynamicType;
+    } else {
+      return returnType.type;
+    }
+  }
+
+  /**
    * Return the class element that represents the class whose name was provided.
    * @param identifier the name from the declaration of a class
    * @return the class element that represents the class
    */
   ClassElementImpl getClassElement(SimpleIdentifier identifier) {
     if (identifier == null) {
       return null;
     }
     Element element = identifier.element;
     if (element is! ClassElementImpl) {
@@ skipping 37 matching lines @@
         } else {
           return CompileTimeErrorCode.NEW_WITH_INVALID_TYPE_PARAMETERS;
         }
       }
     }
     return StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
   }
 
   /**
    * Given the multiple elements to which a single name could potentially be resolved, return the
-   * single interface type that should be used, or {@code null} if there is no clear choice.
+   * single interface type that should be used, or `null` if there is no clear choice.
    * @param elements the elements to which a single name could potentially be resolved
    * @return the single interface type that should be used for the type name
    */
   InterfaceType getType(List<Element> elements) {
     InterfaceType type = null;
     for (Element element in elements) {
       if (element is ClassElement) {
         if (type != null) {
           return null;
         }
@@ skipping 39 matching lines @@
     if (typeName is SimpleIdentifier) {
       return typeName as SimpleIdentifier;
     } else {
       return ((typeName as PrefixedIdentifier)).identifier;
     }
   }
 
   /**
    * Checks if the given type name is used as the type in an as expression.
    * @param typeName the type name to analyzer
-   * @return {@code true} if the given type name is used as the type in an as expression
+   * @return `true` if the given type name is used as the type in an as expression
    */
   bool isTypeNameInAsExpression(TypeName typeName) {
     ASTNode parent = typeName.parent;
     if (parent is AsExpression) {
       AsExpression asExpression = parent as AsExpression;
       return identical(asExpression.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the exception type in a catch clause.
    * @param typeName the type name to analyzer
-   * @return {@code true} if the given type name is used as the exception type in a catch clause
+   * @return `true` if the given type name is used as the exception type in a catch clause
    */
   bool isTypeNameInCatchClause(TypeName typeName) {
     ASTNode parent = typeName.parent;
     if (parent is CatchClause) {
       CatchClause catchClause = parent as CatchClause;
       return identical(catchClause.exceptionType, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the type in an instance creation expression.
    * @param typeName the type name to analyzer
-   * @return {@code true} if the given type name is used as the type in an instance creation
+   * @return `true` if the given type name is used as the type in an instance creation
    * expression
    */
   bool isTypeNameInInstanceCreationExpression(TypeName typeName) {
     ASTNode parent = typeName.parent;
     if (parent is ConstructorName && parent.parent is InstanceCreationExpression) {
       ConstructorName constructorName = parent as ConstructorName;
       return constructorName != null && identical(constructorName.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is used as the type in an is expression.
    * @param typeName the type name to analyzer
-   * @return {@code true} if the given type name is used as the type in an is expression
+   * @return `true` if the given type name is used as the type in an is expression
    */
   bool isTypeNameInIsExpression(TypeName typeName) {
     ASTNode parent = typeName.parent;
     if (parent is IsExpression) {
       IsExpression isExpression = parent as IsExpression;
       return identical(isExpression.type, typeName);
     }
     return false;
   }
 
   /**
    * Checks if the given type name is the target in a redirected constructor.
    * @param typeName the type name to analyzer
-   * @return {@code true} if the given type name is used as the type in a redirected constructor
+   * @return `true` if the given type name is used as the type in a redirected constructor
    */
   bool isTypeNameTargetInRedirectedConstructor(TypeName typeName) {
     ASTNode parent = typeName.parent;
     if (parent is ConstructorName) {
       ConstructorName constructorName = parent as ConstructorName;
       parent = constructorName.parent;
       if (parent is ConstructorDeclaration) {
         ConstructorDeclaration constructorDeclaration = parent as ConstructorDeclaration;
         return constructorName == constructorDeclaration.redirectedConstructor;
       }
@@ skipping 117 matching lines @@
           prefix.element = prefixElement;
         }
       }
     }
   }
 
   /**
    * Set the return type and parameter type information for the given function type based on the
    * given return type and parameter elements.
    * @param functionType the function type to be filled in
-   * @param returnType the return type of the function, or {@code null} if no type was declared
    * @param parameters the elements representing the parameters to the function
    */
-  void setTypeInformation(FunctionTypeImpl functionType, TypeName returnType2, List<ParameterElement> parameters) {
+  void setTypeInformation(FunctionTypeImpl functionType, List<ParameterElement> parameters) {
     List<Type2> normalParameterTypes = new List<Type2>();
     List<Type2> optionalParameterTypes = new List<Type2>();
     LinkedHashMap<String, Type2> namedParameterTypes = new LinkedHashMap<String, Type2>();
     for (ParameterElement parameter in parameters) {
       while (true) {
         if (parameter.parameterKind == ParameterKind.REQUIRED) {
           normalParameterTypes.add(parameter.type);
         } else if (parameter.parameterKind == ParameterKind.POSITIONAL) {
           optionalParameterTypes.add(parameter.type);
         } else if (parameter.parameterKind == ParameterKind.NAMED) {
           namedParameterTypes[parameter.name] = parameter.type;
         }
         break;
       }
     }
     if (!normalParameterTypes.isEmpty) {
       functionType.normalParameterTypes = new List.from(normalParameterTypes);
     }
     if (!optionalParameterTypes.isEmpty) {
       functionType.optionalParameterTypes = new List.from(optionalParameterTypes);
     }
     if (!namedParameterTypes.isEmpty) {
       functionType.namedParameterTypes = namedParameterTypes;
     }
-    if (returnType2 == null) {
-      functionType.returnType = _dynamicType;
-    } else {
-      functionType.returnType = returnType2.type;
-    }
   }
 }
 /**
- * Instances of the class {@code ClassScope} implement the scope defined by a class.
+ * Instances of the class `ClassScope` implement the scope defined by a class.
  * @coverage dart.engine.resolver
  */
 class ClassScope extends EnclosedScope {
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param typeElement the element representing the type represented by this scope
    */
   ClassScope(Scope enclosingScope, ClassElement typeElement) : super(new EnclosedScope(enclosingScope)) {
@@ skipping 29 matching lines @@
    * @param typeElement the element representing the type represented by this scope
    */
   void defineTypeParameters(ClassElement typeElement) {
     Scope parameterScope = enclosingScope;
     for (TypeVariableElement parameter in typeElement.typeVariables) {
       parameterScope.define(parameter);
     }
   }
 }
 /**
- * Instances of the class {@code EnclosedScope} implement a scope that is lexically enclosed in
+ * Instances of the class `EnclosedScope` implement a scope that is lexically enclosed in
  * another scope.
  * @coverage dart.engine.resolver
  */
 class EnclosedScope extends Scope {
 
   /**
    * The scope in which this scope is lexically enclosed.
    */
   Scope _enclosingScope;
 
@@ skipping 14 matching lines @@
   Scope get enclosingScope => _enclosingScope;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element element = localLookup(name, referencingLibrary);
     if (element != null) {
       return element;
     }
     return _enclosingScope.lookup3(identifier, name, referencingLibrary);
   }
 }
 /**
- * Instances of the class {@code FunctionScope} implement the scope defined by a function.
+ * Instances of the class `FunctionScope` implement the scope defined by a function.
  * @coverage dart.engine.resolver
  */
 class FunctionScope extends EnclosedScope {
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param functionElement the element representing the type represented by this scope
    */
   FunctionScope(Scope enclosingScope, ExecutableElement functionElement) : super(new EnclosedScope(enclosingScope)) {
@@ skipping 13 matching lines @@
       }
     }
     for (ParameterElement parameter in functionElement.parameters) {
       if (!parameter.isInitializingFormal()) {
         parameterScope.define(parameter);
       }
     }
   }
 }
 /**
- * Instances of the class {@code FunctionTypeScope} implement the scope defined by a function type
+ * Instances of the class `FunctionTypeScope` implement the scope defined by a function type
  * alias.
  * @coverage dart.engine.resolver
  */
 class FunctionTypeScope extends EnclosedScope {
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param typeElement the element representing the type alias represented by this scope
    */
@@ skipping 17 matching lines @@
    * @param typeElement the element representing the type represented by this scope
    */
   void defineTypeVariables(FunctionTypeAliasElement typeElement) {
     Scope typeVariableScope = enclosingScope;
     for (TypeVariableElement typeVariable in typeElement.typeVariables) {
       typeVariableScope.define(typeVariable);
     }
   }
 }
 /**
- * Instances of the class {@code LabelScope} represent a scope in which a single label is defined.
+ * Instances of the class `LabelScope` represent a scope in which a single label is defined.
  * @coverage dart.engine.resolver
  */
 class LabelScope {
 
   /**
    * The label scope enclosing this label scope.
    */
   LabelScope _outerScope;
 
   /**
    * The label defined in this scope.
    */
   String _label;
 
   /**
    * The element to which the label resolves.
    */
   LabelElement _element;
 
   /**
-   * The marker used to look up a label element for an unlabeled {@code break} or {@code continue}.
+   * The marker used to look up a label element for an unlabeled `break` or `continue`.
    */
   static String EMPTY_LABEL = "";
 
   /**
-   * The label element returned for scopes that can be the target of an unlabeled {@code break} or{@code continue}.
+   * The label element returned for scopes that can be the target of an unlabeled `break` or`continue`.
    */
   static SimpleIdentifier _EMPTY_LABEL_IDENTIFIER = new SimpleIdentifier.full(new sc.StringToken(sc.TokenType.IDENTIFIER, "", 0));
 
   /**
-   * Initialize a newly created scope to represent the potential target of an unlabeled{@code break} or {@code continue}.
+   * Initialize a newly created scope to represent the potential target of an unlabeled`break` or `continue`.
    * @param outerScope the label scope enclosing the new label scope
-   * @param onSwitchStatement {@code true} if this label is associated with a {@code switch}statement
-   * @param onSwitchMember {@code true} if this label is associated with a {@code switch} member
+   * @param onSwitchStatement `true` if this label is associated with a `switch`statement
+   * @param onSwitchMember `true` if this label is associated with a `switch` member
    */
   LabelScope.con1(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
-    _jtd_constructor_287_impl(outerScope, onSwitchStatement, onSwitchMember);
+    _jtd_constructor_288_impl(outerScope, onSwitchStatement, onSwitchMember);
   }
-  _jtd_constructor_287_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
-    _jtd_constructor_288_impl(outerScope, EMPTY_LABEL, new LabelElementImpl(_EMPTY_LABEL_IDENTIFIER, onSwitchStatement, onSwitchMember));
+  _jtd_constructor_288_impl(LabelScope outerScope, bool onSwitchStatement, bool onSwitchMember) {
+    _jtd_constructor_289_impl(outerScope, EMPTY_LABEL, new LabelElementImpl(_EMPTY_LABEL_IDENTIFIER, onSwitchStatement, onSwitchMember));
   }
 
   /**
    * Initialize a newly created scope to represent the given label.
    * @param outerScope the label scope enclosing the new label scope
    * @param label the label defined in this scope
    * @param element the element to which the label resolves
    */
   LabelScope.con2(LabelScope outerScope2, String label2, LabelElement element2) {
-    _jtd_constructor_288_impl(outerScope2, label2, element2);
+    _jtd_constructor_289_impl(outerScope2, label2, element2);
   }
-  _jtd_constructor_288_impl(LabelScope outerScope2, String label2, LabelElement element2) {
+  _jtd_constructor_289_impl(LabelScope outerScope2, String label2, LabelElement element2) {
     this._outerScope = outerScope2;
     this._label = label2;
     this._element = element2;
   }
 
   /**
-   * Return the label element corresponding to the given label, or {@code null} if the given label
+   * Return the label element corresponding to the given label, or `null` if the given label
    * is not defined in this scope.
    * @param targetLabel the label being looked up
    * @return the label element corresponding to the given label
    */
   LabelElement lookup(SimpleIdentifier targetLabel) => lookup2(targetLabel.name);
 
   /**
-   * Return the label element corresponding to the given label, or {@code null} if the given label
+   * Return the label element corresponding to the given label, or `null` if the given label
    * is not defined in this scope.
    * @param targetLabel the label being looked up
    * @return the label element corresponding to the given label
    */
   LabelElement lookup2(String targetLabel) {
     if (_label == targetLabel) {
       return _element;
     } else if (_outerScope != null) {
       return _outerScope.lookup2(targetLabel);
     } else {
       return null;
     }
   }
 }
 /**
- * Instances of the class {@code LibraryImportScope} represent the scope containing all of the names
+ * Instances of the class `LibraryImportScope` represent the scope containing all of the names
  * available from imported libraries.
  * @coverage dart.engine.resolver
  */
 class LibraryImportScope extends Scope {
 
   /**
-   * @return {@code true} if the given {@link Identifier} is the part of type annotation.
+   * @return `true` if the given [Identifier] is the part of type annotation.
    */
   static bool isTypeAnnotation(Identifier identifier) {
     ASTNode parent = identifier.parent;
     if (parent is TypeName) {
       ASTNode parent2 = parent.parent;
       if (parent2 is FunctionDeclaration) {
         FunctionDeclaration decl = parent2 as FunctionDeclaration;
         return identical(decl.returnType, parent);
       }
       if (parent2 is FunctionTypeAlias) {
@@ skipping 108 matching lines @@
    * which namespaces will be created
    */
   void createImportedNamespaces(LibraryElement definingLibrary) {
     NamespaceBuilder builder = new NamespaceBuilder();
     for (ImportElement element in definingLibrary.imports) {
       _importedNamespaces.add(builder.createImportNamespace(element));
     }
   }
 }
 /**
- * Instances of the class {@code LibraryScope} implement a scope containing all of the names defined
+ * Instances of the class `LibraryScope` implement a scope containing all of the names defined
  * in a given library.
  * @coverage dart.engine.resolver
  */
 class LibraryScope extends EnclosedScope {
 
   /**
    * Initialize a newly created scope representing the names defined in the given library.
    * @param definingLibrary the element representing the library represented by this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
@@ skipping 44 matching lines @@
     for (PrefixElement prefix in definingLibrary.prefixes) {
       define(prefix);
     }
     defineLocalNames(definingLibrary.definingCompilationUnit);
     for (CompilationUnitElement compilationUnit in definingLibrary.parts) {
       defineLocalNames(compilationUnit);
     }
   }
 }
 /**
- * Instances of the class {@code Namespace} implement a mapping of identifiers to the elements
+ * Instances of the class `Namespace` implement a mapping of identifiers to the elements
  * represented by those identifiers. Namespaces are the building blocks for scopes.
  * @coverage dart.engine.resolver
  */
 class Namespace {
 
   /**
    * A table mapping names that are defined in this namespace to the element representing the thing
    * declared with that name.
    */
   Map<String, Element> _definedNames;
@@ skipping 20 matching lines @@
    */
   Element get(String name) => _definedNames[name];
 
   /**
    * Return a table containing the same mappings as those defined by this namespace.
    * @return a table containing the same mappings as those defined by this namespace
    */
   Map<String, Element> get definedNames => new Map<String, Element>.from(_definedNames);
 }
 /**
- * Instances of the class {@code NamespaceBuilder} are used to build a {@code Namespace}. Namespace
+ * Instances of the class `NamespaceBuilder` are used to build a `Namespace`. Namespace
  * builders are thread-safe and re-usable.
  * @coverage dart.engine.resolver
  */
 class NamespaceBuilder {
 
   /**
-   * Create a namespace representing the export namespace of the given {@link ExportElement}.
+   * Create a namespace representing the export namespace of the given [ExportElement].
    * @param element the export element whose export namespace is to be created
    * @return the export namespace that was created
    */
   Namespace createExportNamespace(ExportElement element) {
     LibraryElement exportedLibrary = element.exportedLibrary;
     if (exportedLibrary == null) {
       return Namespace.EMPTY;
     }
     Map<String, Element> definedNames = createExportMapping(exportedLibrary, new Set<LibraryElement>());
     definedNames = apply(definedNames, element.combinators);
@@ skipping 184 matching lines @@
       String setterName = "${name}=";
       element = definedNames[setterName];
       if (element != null) {
         newNames[setterName] = element;
       }
     }
     return newNames;
   }
 }
 /**
- * The abstract class {@code Scope} defines the behavior common to name scopes used by the resolver
+ * The abstract class `Scope` defines the behavior common to name scopes used by the resolver
  * to determine which names are visible at any given point in the code.
  * @coverage dart.engine.resolver
  */
 abstract class Scope {
 
   /**
    * The prefix used to mark an identifier as being private to its library.
    */
   static String PRIVATE_NAME_PREFIX = "_";
 
   /**
    * The suffix added to the declared name of a setter when looking up the setter. Used to
    * disambiguate between a getter and a setter that have the same name.
    */
   static String SETTER_SUFFIX = "=";
 
   /**
    * The name used to look up the method used to implement the unary minus operator. Used to
    * disambiguate between the unary and binary operators.
    */
   static String UNARY_MINUS = "unary-";
 
   /**
-   * Return {@code true} if the given name is a library-private name.
+   * Return `true` if the given name is a library-private name.
    * @param name the name being tested
-   * @return {@code true} if the given name is a library-private name
+   * @return `true` if the given name is a library-private name
    */
   static bool isPrivateName(String name) => name != null && name.startsWith(PRIVATE_NAME_PREFIX);
 
   /**
    * A table mapping names that are defined in this scope to the element representing the thing
    * declared with that name.
    */
   Map<String, Element> _definedNames = new Map<String, Element>();
 
   /**
    * Add the given element to this scope. If there is already an element with the given name defined
    * in this scope, then an error will be generated and the original element will continue to be
    * mapped to the name. If there is an element with the given name in an enclosing scope, then a
    * warning will be generated but the given element will hide the inherited element.
    * @param element the element to be added to this scope
    */
   void define(Element element) {
     String name = getName(element);
     if (name != null && !name.isEmpty) {
       if (_definedNames.containsKey(name)) {
         errorListener.onError(getErrorForDuplicate(_definedNames[name], element));
       } else {
         _definedNames[name] = element;
       }
     }
   }
 
   /**
-   * Return the element with which the given identifier is associated, or {@code null} if the name
+   * Return the element with which the given identifier is associated, or `null` if the name
    * is not defined within this scope.
    * @param identifier the identifier 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 identifier is associated
    */
   Element lookup(Identifier identifier, LibraryElement referencingLibrary) => lookup3(identifier, identifier.name, referencingLibrary);
 
   /**
    * Add the given element to this scope without checking for duplication or hiding.
@@ skipping 40 matching lines @@
   AnalysisErrorListener get errorListener;
 
   /**
    * Return the source object representing the compilation unit with which errors related to this
    * scope should be associated.
    * @return the source object with which errors should be associated
    */
   Source get source => definingLibrary.definingCompilationUnit.source;
 
   /**
-   * Return the element with which the given name is associated, or {@code null} if the name is not
+   * 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
    */
   Element localLookup(String name, LibraryElement referencingLibrary) => _definedNames[name];
 
   /**
-   * Return the element with which the given name is associated, or {@code null} if the name is not
+   * Return the element with which the given name is associated, or `null` if the name is not
    * defined within this scope.
    * @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 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
    */
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary);
 
   /**
    * Return the name that will be used to look up the given element.
    * @param element the element whose look-up name is to be returned
    * @return the name that will be used to look up the given element
    */
   String getName(Element element) {
     if (element is MethodElement) {
       MethodElement method = element as MethodElement;
       if (method.name == "-" && method.parameters.length == 0) {
         return UNARY_MINUS;
       }
     }
     return element.name;
   }
 }
 /**
- * Instances of the class {@code ConstantVerifier} traverse an AST structure looking for additional
+ * Instances of the class `ConstantVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver. In particular, it looks for errors
  * and warnings related to constant expressions.
  * @coverage dart.engine.resolver
  */
 class ConstantVerifier extends RecursiveASTVisitor<Object> {
 
   /**
    * The error reporter by which errors will be reported.
    */
   ErrorReporter _errorReporter;
@@ skipping 26 matching lines @@
     this._errorReporter = errorReporter;
     this._boolType = typeProvider.boolType;
     this._intType = typeProvider.intType;
     this._numType = typeProvider.numType;
     this._stringType = typeProvider.stringType;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     if (node.constKeyword != null) {
       validateInitializers(node);
     }
+    validateDefaultValues(node.parameters);
     return super.visitConstructorDeclaration(node);
   }
   Object visitFunctionExpression(FunctionExpression node) {
     super.visitFunctionExpression(node);
     validateDefaultValues(node.parameters);
     return null;
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     validateConstantArguments(node);
     return super.visitInstanceCreationExpression(node);
@@ skipping 67 matching lines @@
         result = validate(initializer, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
         element.evaluationResult = result;
       } else if (result is ErrorResult) {
         reportErrors(result, CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
       }
     }
     return null;
   }
 
   /**
-   * Return {@code true} if the given value is the result of evaluating an expression whose value is
+   * Return `true` if the given value is the result of evaluating an expression whose value is
    * a valid key in a const map literal. Keys in const map literals must be either a string, number,
    * boolean, list, map, or null.
    * @param value
-   * @return {@code true} if the given value is a valid key in a const map literal
+   * @return `true` if the given value is a valid key in a const map literal
    */
   bool isValidConstMapKey(Object value) => true;
 
   /**
    * If the given result represents one or more errors, report those errors. Except for special
    * cases, use the given error code rather than the one reported in the error.
    * @param result the result containing any errors that need to be reported
    * @param errorCode the error code to be used if the result represents an error
    */
   void reportErrors(EvaluationResultImpl result, ErrorCode errorCode2) {
     if (result is ErrorResult) {
       for (ErrorResult_ErrorData data in ((result as ErrorResult)).errorData) {
         ErrorCode dataErrorCode = data.errorCode;
         if (identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_INT) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM)) {
           _errorReporter.reportError2(dataErrorCode, data.node, []);
         } else {
           _errorReporter.reportError2(errorCode2, data.node, []);
         }
       }
     }
   }
 
   /**
    * Validate that the given expression is a compile time constant. Return the value of the compile
-   * time constant, or {@code null} if the expression is not a compile time constant.
+   * time constant, or `null` if the expression is not a compile time constant.
    * @param expression the expression to be validated
    * @param errorCode the error code to be used if the expression is not a compile time constant
    * @return the value of the compile time constant
    */
   EvaluationResultImpl validate(Expression expression, ErrorCode errorCode) {
     EvaluationResultImpl result = expression.accept(new ConstantVisitor());
     reportErrors(result, errorCode);
     return result;
   }
 
@@ skipping 26 matching lines @@
   void validateDefaultValues(FormalParameterList parameters2) {
     if (parameters2 == null) {
       return;
     }
     for (FormalParameter parameter in parameters2.parameters) {
       if (parameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultParameter = parameter as DefaultFormalParameter;
         Expression defaultValue = defaultParameter.defaultValue;
         if (defaultValue != null) {
           EvaluationResultImpl result = validate(defaultValue, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
-          if (defaultParameter.isConst()) {
-            VariableElementImpl element = parameter.element as VariableElementImpl;
-            element.evaluationResult = result;
-          }
+          VariableElementImpl element = parameter.element as VariableElementImpl;
+          element.evaluationResult = result;
         }
       }
     }
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    * @param parameterElements the elements of parameters of constant constructor, they are
    * considered as a valid potentially constant expressions
    * @param expression the expression to validate
@@ skipping 68 matching lines @@
             return ValidResult.RESULT_STRING;
           }
         }
         return ValidResult.RESULT_OBJECT;
       }
     }
     return super.visitSimpleIdentifier(node);
   }
 }
 /**
- * Instances of the class {@code ErrorVerifier} traverse an AST structure looking for additional
+ * Instances of the class `ErrorVerifier` traverse an AST structure looking for additional
  * errors and warnings not covered by the parser and resolver.
  * @coverage dart.engine.resolver
  */
 class ErrorVerifier extends RecursiveASTVisitor<Object> {
 
   /**
    * Checks if the given expression is the reference to the type.
    * @param expr the expression to evaluate
-   * @return {@code true} if the given expression is the reference to the type
+   * @return `true` if the given expression is the reference to the type
    */
   static bool isTypeReference(Expression expr) {
     if (expr is Identifier) {
       Identifier identifier = expr as Identifier;
       return identifier.element is ClassElement;
     }
     return false;
   }
 
   /**
@@ skipping 21 matching lines @@
    */
   InheritanceManager _inheritanceManager;
 
   /**
    * A flag indicating whether we are running in strict mode. In strict mode, error reporting is
    * based exclusively on the static type information.
    */
   bool _strictMode = false;
 
   /**
-   * This is set to {@code true} iff the visitor is currently visiting children nodes of a{@link ConstructorDeclaration} and the constructor is 'const'.
+   * This is set to `true` iff the visitor is currently visiting children nodes of a[ConstructorDeclaration] and the constructor is 'const'.
    * @see #visitConstructorDeclaration(ConstructorDeclaration)
    */
   bool _isEnclosingConstructorConst = false;
 
   /**
-   * This is set to {@code true} iff the visitor is currently visiting children nodes of a{@link CatchClause}.
+   * This is set to `true` iff the visitor is currently visiting children nodes of a[CatchClause].
    * @see #visitCatchClause(CatchClause)
    */
   bool _isInCatchClause = false;
 
   /**
-   * This is set to {@code true} iff the visitor is currently visiting a{@link ConstructorInitializer}.
+   * This is set to `true` iff the visitor is currently visiting a[ConstructorInitializer].
    */
   bool _isInConstructorInitializer = false;
 
   /**
-   * This is set to {@code true} iff the visitor is currently visiting code in the SDK.
+   * This is set to `true` iff the visitor is currently visiting code in the SDK.
    */
   bool _isInSystemLibrary = false;
 
   /**
-   * The class containing the AST nodes being visited, or {@code null} if we are not in the scope of
+   * The class containing the AST nodes being visited, or `null` if we are not in the scope of
    * a class.
    */
   ClassElement _enclosingClass;
 
   /**
-   * The method or function that we are currently visiting, or {@code null} if we are not inside a
+   * The method or function that we are currently visiting, or `null` if we are not inside a
    * method or function.
    */
   ExecutableElement _enclosingFunction;
 
   /**
    * This map is initialized when visiting the contents of a class declaration. If the visitor is
-   * not in an enclosing class declaration, then the map is set to {@code null}.
-   * <p>
-   * When set the map maps the set of {@link FieldElement}s in the class to an{@link INIT_STATE#NOT_INIT} or {@link INIT_STATE#INIT_IN_DECLARATION}. <code>checkFor*</code>
-   * methods, specifically {@link #checkForAllFinalInitializedErrorCodes(ConstructorDeclaration)},
+   * not in an enclosing class declaration, then the map is set to `null`.
+   *
+   * When set the map maps the set of [FieldElement]s in the class to an[INIT_STATE#NOT_INIT] or [INIT_STATE#INIT_IN_DECLARATION]. <code>checkFor*</code>
+   * methods, specifically [checkForAllFinalInitializedErrorCodes],
    * can make a copy of the map to compute error code states. <code>checkFor*</code> methods should
-   * only ever make a copy, or read from this map after it has been set in{@link #visitClassDeclaration(ClassDeclaration)}.
+   * only ever make a copy, or read from this map after it has been set in[visitClassDeclaration].
    * @see #visitClassDeclaration(ClassDeclaration)
    * @see #checkForAllFinalInitializedErrorCodes(ConstructorDeclaration)
    */
   Map<FieldElement, INIT_STATE> _initialFieldElementsMap;
 
   /**
    * A table mapping name of the library to the export directive which export this library.
    */
   Map<String, LibraryElement> _nameToExportElement = new Map<String, LibraryElement>();
 
   /**
    * A table mapping name of the library to the import directive which import this library.
    */
   Map<String, LibraryElement> _nameToImportElement = new Map<String, LibraryElement>();
 
   /**
    * A table mapping names to the export elements exported them.
    */
   Map<String, ExportElement> _exportedNames = new Map<String, ExportElement>();
 
   /**
    * A set of the names of the variable initializers we are visiting now.
    */
   Set<String> _namesForReferenceToDeclaredVariableInInitializer = new Set<String>();
 
   /**
-   * A list of types used by the {@link CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS} and{@link CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS} error codes.
+   * A list of types used by the [CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS] and[CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS] error codes.
    */
   List<InterfaceType> _DISALLOWED_TYPES_TO_EXTEND_OR_IMPLEMENT;
   ErrorVerifier(ErrorReporter errorReporter, LibraryElement currentLibrary, TypeProvider typeProvider, InheritanceManager inheritanceManager) {
     this._errorReporter = errorReporter;
     this._currentLibrary = currentLibrary;
     this._isInSystemLibrary = currentLibrary.source.isInSystemLibrary();
     this._typeProvider = typeProvider;
     this._inheritanceManager = inheritanceManager;
     _strictMode = currentLibrary.context.analysisOptions.strictMode;
     _isEnclosingConstructorConst = false;
@@ skipping 39 matching lines @@
   }
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement outerClass = _enclosingClass;
     try {
       _enclosingClass = node.element;
       WithClause withClause = node.withClause;
       ImplementsClause implementsClause = node.implementsClause;
       ExtendsClause extendsClause = node.extendsClause;
       checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
       checkForMemberWithClassName();
+      checkForNoDefaultSuperConstructorImplicit(node);
       checkForAllMixinErrorCodes(withClause);
       if (implementsClause != null || extendsClause != null) {
         if (!checkForImplementsDisallowedClass(implementsClause) && !checkForExtendsDisallowedClass(extendsClause)) {
           checkForNonAbstractClassInheritsAbstractMember(node);
           checkForInconsistentMethodInheritance();
           checkForRecursiveInterfaceInheritance(_enclosingClass, new List<ClassElement>());
         }
       }
       ClassElement classElement = node.element;
       if (classElement != null) {
@@ skipping 65 matching lines @@
   Object visitDoStatement(DoStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitDoStatement(node);
   }
   Object visitExportDirective(ExportDirective node) {
     checkForAmbiguousExport(node);
     checkForExportDuplicateLibraryName(node);
     checkForExportInternalLibrary(node);
     return super.visitExportDirective(node);
   }
+  Object visitExpressionFunctionBody(ExpressionFunctionBody node) {
+    FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
+    Type2 expectedReturnType = functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
+    checkForReturnOfInvalidType(node.expression, expectedReturnType);
+    return super.visitExpressionFunctionBody(node);
+  }
   Object visitFieldDeclaration(FieldDeclaration node) {
     if (!node.isStatic()) {
       VariableDeclarationList variables = node.fields;
       if (variables.isConst()) {
         _errorReporter.reportError4(CompileTimeErrorCode.CONST_INSTANCE_FIELD, variables.keyword, []);
       }
     }
     return super.visitFieldDeclaration(node);
   }
   Object visitFieldFormalParameter(FieldFormalParameter node) {
     checkForConstFormalParameter(node);
     checkForFieldInitializingFormalRedirectingConstructor(node);
     return super.visitFieldFormalParameter(node);
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerFunction = _enclosingFunction;
     try {
       SimpleIdentifier identifier = node.name;
-      String methoName = "";
+      String methodName = "";
       if (identifier != null) {
-        methoName = identifier.name;
+        methodName = identifier.name;
       }
       _enclosingFunction = node.element;
       if (node.isSetter() || node.isGetter()) {
-        checkForMismatchedAccessorTypes(node, methoName);
+        checkForMismatchedAccessorTypes(node, methodName);
         if (node.isSetter()) {
           FunctionExpression functionExpression = node.functionExpression;
           if (functionExpression != null) {
             checkForWrongNumberOfParametersForSetter(node.name, functionExpression.parameters);
           }
           TypeName returnType = node.returnType;
           checkForNonVoidReturnTypeForSetter(returnType);
         }
       }
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingFunction = outerFunction;
     }
   }
   Object visitFunctionExpression(FunctionExpression node) {
-    ExecutableElement outerFunction = _enclosingFunction;
-    try {
-      _enclosingFunction = node.element;
+    if (node.parent is! FunctionDeclaration) {
+      ExecutableElement outerFunction = _enclosingFunction;
+      try {
+        _enclosingFunction = node.element;
+        return super.visitFunctionExpression(node);
+      } finally {
+        _enclosingFunction = outerFunction;
+      }
+    } else {
       return super.visitFunctionExpression(node);
-    } finally {
-      _enclosingFunction = outerFunction;
     }
   }
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
     checkForDefaultValueInFunctionTypeAlias(node);
     return super.visitFunctionTypeAlias(node);
   }
   Object visitIfStatement(IfStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitIfStatement(node);
@@ skipping 189 matching lines @@
     return super.visitVariableDeclarationStatement(node);
   }
   Object visitWhileStatement(WhileStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitWhileStatement(node);
   }
 
   /**
    * This verifies that the passed constructor declaration does not violate any of the error codes
    * relating to the initialization of fields in the enclosing class.
-   * @param node the {@link ConstructorDeclaration} to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param node the [ConstructorDeclaration] to evaluate
+   * @return `true` if and only if an error code is generated on the passed node
    * @see #initialFieldElementsMap
    * @see CompileTimeErrorCode#FINAL_INITIALIZED_IN_DECLARATION_AND_CONSTRUCTOR
    * @see CompileTimeErrorCode#FINAL_INITIALIZED_MULTIPLE_TIMES
    */
   bool checkForAllFinalInitializedErrorCodes(ConstructorDeclaration node) {
     if (node.factoryKeyword != null || node.redirectedConstructor != null || node.externalKeyword != null) {
       return false;
     }
     bool foundError = false;
     Map<FieldElement, INIT_STATE> fieldElementsMap = new Map<FieldElement, INIT_STATE>.from(_initialFieldElementsMap);
@@ skipping 45 matching lines @@
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
 
   /**
    * This checks the passed method declaration against override-error codes.
-   * @param node the {@link MethodDeclaration} to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param node the [MethodDeclaration] to evaluate
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#INSTANCE_METHOD_NAME_COLLIDES_WITH_SUPERCLASS_STATIC
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_REQUIRED
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_POSITIONAL
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_NAMED
    * @see StaticWarningCode#INVALID_GETTER_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE
+   * @see StaticWarningCode#INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
    */
   bool checkForAllInvalidOverrideErrorCodes(MethodDeclaration node) {
     if (_enclosingClass == null || node.isStatic() || node.body is NativeFunctionBody) {
       return false;
     }
     ExecutableElement executableElement = node.element;
     if (executableElement == null) {
       return false;
     }
     SimpleIdentifier methodName = node.name;
@@ skipping 110 matching lines @@
               break;
             }
           }
         }
         if (parameterToSelect != null) {
           _errorReporter.reportError2(StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE, parameterToSelect, [overridingType.displayName, overriddenNamedPTEntry.getValue().displayName, overriddenExecutable.enclosingElement.displayName]);
           return true;
         }
       }
     }
-    return false;
+    bool foundError = false;
+    List<FormalParameter> formalParameters = new List<FormalParameter>();
+    List<ParameterElementImpl> parameterElts = new List<ParameterElementImpl>();
+    List<ParameterElementImpl> overriddenParameterElts = new List<ParameterElementImpl>();
+    List<ParameterElement> overriddenPEs = overriddenExecutable.parameters;
+    for (FormalParameter formalParameter in parameterNodeList) {
+      if (formalParameter.kind.isOptional()) {
+        formalParameters.add(formalParameter);
+        parameterElts.add((formalParameter.element as ParameterElementImpl));
+      }
+    }
+    for (ParameterElement parameterElt in overriddenPEs) {
+      if (parameterElt.parameterKind.isOptional()) {
+        overriddenParameterElts.add((parameterElt as ParameterElementImpl));
+      }
+    }
+    if (parameterElts.length > 0) {
+      if (identical(parameterElts[0].parameterKind, ParameterKind.NAMED)) {
+        for (int i = 0; i < parameterElts.length; i++) {
+          ParameterElementImpl parameterElt = parameterElts[i];
+          EvaluationResultImpl result = parameterElt.evaluationResult;
+          if (result == null || identical(result, ValidResult.RESULT_OBJECT)) {
+            continue;
+          }
+          String parameterName = parameterElt.name;
+          for (int j = 0; j < overriddenParameterElts.length; j++) {
+            ParameterElementImpl overriddenParameterElt = overriddenParameterElts[j];
+            String overriddenParameterName = overriddenParameterElt.name;
+            if (parameterName != null && parameterName == overriddenParameterName) {
+              EvaluationResultImpl overriddenResult = overriddenParameterElt.evaluationResult;
+              if (overriddenResult == null || identical(result, ValidResult.RESULT_OBJECT)) {
+                break;
+              }
+              if (!result.equalValues(overriddenResult)) {
+                _errorReporter.reportError2(StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_NAMED, formalParameters[i], [overriddenExecutable.enclosingElement.displayName, overriddenExecutable.displayName, parameterName]);
+                foundError = true;
+              }
+            }
+          }
+        }
+      } else {
+        for (int i = 0; i < parameterElts.length && i < overriddenParameterElts.length; i++) {
+          ParameterElementImpl parameterElt = parameterElts[i];
+          EvaluationResultImpl result = parameterElt.evaluationResult;
+          if (result == null || identical(result, ValidResult.RESULT_OBJECT)) {
+            continue;
+          }
+          ParameterElementImpl overriddenParameterElt = overriddenParameterElts[i];
+          EvaluationResultImpl overriddenResult = overriddenParameterElt.evaluationResult;
+          if (overriddenResult == null || identical(result, ValidResult.RESULT_OBJECT)) {
+            continue;
+          }
+          if (!result.equalValues(overriddenResult)) {
+            _errorReporter.reportError2(StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL, formalParameters[i], [overriddenExecutable.enclosingElement.displayName, overriddenExecutable.displayName]);
+            foundError = true;
+          }
+        }
+      }
+    }
+    return foundError;
   }
 
   /**
    * This verifies that all classes of the passed 'with' clause are valid.
    * @param node the 'with' clause to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_DECLARES_CONSTRUCTOR
    * @see CompileTimeErrorCode#MIXIN_INHERITS_FROM_NOT_OBJECT
    * @see CompileTimeErrorCode#MIXIN_REFERENCES_SUPER
    */
   bool checkForAllMixinErrorCodes(WithClause withClause) {
     if (withClause == null) {
       return false;
     }
     bool problemReported = false;
     for (TypeName mixinName in withClause.mixinTypes) {
       Type2 mixinType = mixinName.type;
       if (mixinType is! InterfaceType) {
         continue;
       }
       ClassElement mixinElement = ((mixinType as InterfaceType)).element;
       problemReported = javaBooleanOr(problemReported, checkForMixinDeclaresConstructor(mixinName, mixinElement));
       problemReported = javaBooleanOr(problemReported, checkForMixinInheritsNotFromObject(mixinName, mixinElement));
       problemReported = javaBooleanOr(problemReported, checkForMixinReferencesSuper(mixinName, mixinElement));
     }
     return problemReported;
   }
 
   /**
    * This checks error related to the redirected constructors.
    * @param node the constructor declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#REDIRECT_TO_INVALID_RETURN_TYPE
    * @see StaticWarningCode#REDIRECT_TO_INVALID_FUNCTION_TYPE
    * @see StaticWarningCode#REDIRECT_TO_MISSING_CONSTRUCTOR
    */
   bool checkForAllRedirectConstructorErrorCodes(ConstructorDeclaration node) {
     ConstructorName redirectedNode = node.redirectedConstructor;
     if (redirectedNode == null) {
       return false;
     }
     ConstructorElement redirectedElement = redirectedNode.element;
@@ skipping 21 matching lines @@
     if (!redirectedType.isSubtypeOf(constructorType)) {
       _errorReporter.reportError2(StaticWarningCode.REDIRECT_TO_INVALID_FUNCTION_TYPE, redirectedNode, [redirectedType, constructorType]);
       return true;
     }
     return false;
   }
 
   /**
    * This checks that the return statement of the form <i>return e;</i> is not in a generative
    * constructor.
-   * <p>
+   *
    * This checks that return statements without expressions are not in a generative constructor and
-   * the return type is not assignable to {@code null}; that is, we don't have {@code return;} if
+   * the return type is not assignable to `null`; that is, we don't have `return;` if
    * the enclosing method has a return type.
-   * <p>
+   *
    * This checks that the return type matches the type of the declared return type in the enclosing
    * method or function.
    * @param node the return statement to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RETURN_IN_GENERATIVE_CONSTRUCTOR
    * @see StaticWarningCode#RETURN_WITHOUT_VALUE
    * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
    */
   bool checkForAllReturnStatementErrorCodes(ReturnStatement node) {
     FunctionType functionType = _enclosingFunction == null ? null : _enclosingFunction.type;
     Type2 expectedReturnType = functionType == null ? DynamicTypeImpl.instance : functionType.returnType;
     Expression returnExpression = node.expression;
     bool isGenerativeConstructor = _enclosingFunction is ConstructorElement && !((_enclosingFunction as ConstructorElement)).isFactory();
     if (isGenerativeConstructor) {
       if (returnExpression == null) {
         return false;
       }
       _errorReporter.reportError2(CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR, returnExpression, []);
       return true;
     }
     if (returnExpression == null) {
       if (VoidTypeImpl.instance.isAssignableTo(expectedReturnType)) {
         return false;
       }
       _errorReporter.reportError2(StaticWarningCode.RETURN_WITHOUT_VALUE, node, []);
       return true;
     }
-    Type2 staticReturnType = getStaticType(returnExpression);
-    if (expectedReturnType.isVoid()) {
-      if (staticReturnType.isVoid() || staticReturnType.isDynamic() || identical(staticReturnType, BottomTypeImpl.instance)) {
-        return false;
-      }
-      _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [staticReturnType.displayName, expectedReturnType.displayName, _enclosingFunction.displayName]);
-      return true;
-    }
-    bool isStaticAssignable = staticReturnType.isAssignableTo(expectedReturnType);
-    Type2 propagatedReturnType = getPropagatedType(returnExpression);
-    if (_strictMode || propagatedReturnType == null) {
-      if (isStaticAssignable) {
-        return false;
-      }
-      _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [staticReturnType.displayName, expectedReturnType.displayName, _enclosingFunction.displayName]);
-      return true;
-    } else {
-      bool isPropagatedAssignable = propagatedReturnType.isAssignableTo(expectedReturnType);
-      if (isStaticAssignable || isPropagatedAssignable) {
-        return false;
-      }
-      _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [staticReturnType.displayName, expectedReturnType.displayName, _enclosingFunction.displayName]);
-      return true;
-    }
+    return checkForReturnOfInvalidType(returnExpression, expectedReturnType);
   }
 
   /**
    * This verifies that the export namespace of the passed export directive does not export any name
    * already exported by other export directive.
    * @param node the export directive node to report problem on
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#AMBIGUOUS_EXPORT
    */
   bool checkForAmbiguousExport(ExportDirective node) {
     if (node.element is! ExportElement) {
       return false;
     }
     ExportElement exportElement = node.element as ExportElement;
     LibraryElement exportedLibrary = exportElement.exportedLibrary;
     if (exportedLibrary == null) {
       return false;
     }
     Namespace namespace = new NamespaceBuilder().createExportNamespace(exportElement);
     Set<String> newNames = namespace.definedNames.keys.toSet();
     for (String name in newNames) {
       ExportElement prevElement = _exportedNames[name];
       if (prevElement != null && prevElement != exportElement) {
         _errorReporter.reportError2(CompileTimeErrorCode.AMBIGUOUS_EXPORT, node, [name, prevElement.exportedLibrary.definingCompilationUnit.displayName, exportedLibrary.definingCompilationUnit.displayName]);
         return true;
       } else {
         _exportedNames[name] = exportElement;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed argument definition test identifier is a parameter.
-   * @param node the {@link ArgumentDefinitionTest} to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param node the [ArgumentDefinitionTest] to evaluate
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#ARGUMENT_DEFINITION_TEST_NON_PARAMETER
    */
   bool checkForArgumentDefinitionTestNonParameter(ArgumentDefinitionTest node) {
     SimpleIdentifier identifier = node.identifier;
     Element element = identifier.element;
     if (element != null && element is! ParameterElement) {
       _errorReporter.reportError2(CompileTimeErrorCode.ARGUMENT_DEFINITION_TEST_NON_PARAMETER, identifier, [identifier.name]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed arguments can be assigned to their corresponding parameters.
    * @param node the arguments to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
   bool checkForArgumentTypeNotAssignable(ArgumentList argumentList) {
     if (argumentList == null) {
       return false;
     }
     bool problemReported = false;
     for (Expression argument in argumentList.arguments) {
       problemReported = javaBooleanOr(problemReported, checkForArgumentTypeNotAssignable2(argument));
     }
     return problemReported;
   }
 
   /**
    * This verifies that the passed argument can be assigned to their corresponding parameters.
    * @param node the argument to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ARGUMENT_TYPE_NOT_ASSIGNABLE
    */
   bool checkForArgumentTypeNotAssignable2(Expression argument) {
     if (argument == null) {
       return false;
     }
     ParameterElement staticParameterElement = argument.staticParameterElement;
     Type2 staticParameterType = staticParameterElement == null ? null : staticParameterElement.type;
     Type2 staticArgumentType = getStaticType(argument);
     if (staticArgumentType == null || staticParameterType == null) {
@@ skipping 19 matching lines @@
     if (staticArgumentType.isAssignableTo(staticParameterType) || staticArgumentType.isAssignableTo(propagatedParameterType) || propagatedArgumentType.isAssignableTo(staticParameterType) || propagatedArgumentType.isAssignableTo(propagatedParameterType)) {
       return false;
     }
     _errorReporter.reportError2(StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE, argument, [(propagatedArgumentType == null ? staticArgumentType : propagatedArgumentType).displayName, (propagatedParameterType == null ? staticParameterType : propagatedParameterType).displayName]);
     return true;
   }
 
   /**
    * This verifies that left hand side of the passed assignment expression is not final.
    * @param node the assignment expression to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ASSIGNMENT_TO_FINAL
    */
   bool checkForAssignmentToFinal(AssignmentExpression node) {
     Expression leftExpression = node.leftHandSide;
     return checkForAssignmentToFinal2(leftExpression);
   }
 
   /**
    * This verifies that the passed expression is not final.
    * @param node the expression to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#ASSIGNMENT_TO_FINAL
    */
   bool checkForAssignmentToFinal2(Expression expression) {
     Element element = null;
     if (expression is Identifier) {
       element = ((expression as Identifier)).element;
     }
     if (expression is PropertyAccess) {
       element = ((expression as PropertyAccess)).propertyName.element;
     }
@@ skipping 14 matching lines @@
       return false;
     }
     return false;
   }
 
   /**
    * This verifies that the passed identifier is not a keyword, and generates the passed error code
    * on the identifier if it is a keyword.
    * @param identifier the identifier to check to ensure that it is not a keyword
    * @param errorCode if the passed identifier is a keyword then this error code is created on the
-   * identifier, the error code will be one of{@link CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_NAME},{@link CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME} or{@link CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME}
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * identifier, the error code will be one of[CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_NAME],[CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME] or[CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_NAME
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME
    */
   bool checkForBuiltInIdentifierAsName(SimpleIdentifier identifier, ErrorCode errorCode) {
     sc.Token token = identifier.token;
     if (identical(token.type, sc.TokenType.KEYWORD)) {
       _errorReporter.reportError2(errorCode, identifier, [identifier.name]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed variable declaration list does not have a built-in identifier.
    * @param node the variable declaration list to check
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#BUILT_IN_IDENTIFIER_AS_TYPE
    */
   bool checkForBuiltInIdentifierAsName2(VariableDeclarationList node) {
     TypeName typeName = node.type;
     if (typeName != null) {
       Identifier identifier = typeName.name;
       if (identifier is SimpleIdentifier) {
         SimpleIdentifier simpleIdentifier = identifier as SimpleIdentifier;
         sc.Token token = simpleIdentifier.token;
         if (identical(token.type, sc.TokenType.KEYWORD)) {
           if (((token as sc.KeywordToken)).keyword != sc.Keyword.DYNAMIC) {
             _errorReporter.reportError2(CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE, identifier, [identifier.name]);
             return true;
           }
         }
       }
     }
     return false;
   }
 
   /**
    * This verifies that the given switch case is terminated with 'break', 'continue', 'return' or
    * 'throw'.
    * @param node the switch case to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CASE_BLOCK_NOT_TERMINATED
    */
   bool checkForCaseBlockNotTerminated(SwitchCase node) {
     NodeList<Statement> statements = node.statements;
     if (statements.isEmpty) {
       ASTNode parent = node.parent;
       if (parent is SwitchStatement) {
         SwitchStatement switchStatement = parent as SwitchStatement;
         NodeList<SwitchMember> members = switchStatement.members;
         int index = members.indexOf(node);
@@ skipping 14 matching lines @@
       }
     }
     _errorReporter.reportError4(StaticWarningCode.CASE_BLOCK_NOT_TERMINATED, node.keyword, []);
     return true;
   }
 
   /**
    * This verifies that the switch cases in the given switch statement is terminated with 'break',
    * 'continue', 'return' or 'throw'.
    * @param node the switch statement containing the cases to be checked
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CASE_BLOCK_NOT_TERMINATED
    */
   bool checkForCaseBlocksNotTerminated(SwitchStatement node) {
     bool foundError = false;
     NodeList<SwitchMember> members = node.members;
     int lastMember = members.length - 1;
     for (int i = 0; i < lastMember; i++) {
       SwitchMember member = members[i];
       if (member is SwitchCase) {
         foundError = javaBooleanOr(foundError, checkForCaseBlockNotTerminated((member as SwitchCase)));
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the passed switch statement does not have a case expression with the
    * operator '==' overridden.
    * @param node the switch statement to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
    */
   bool checkForCaseExpressionTypeImplementsEquals(SwitchStatement node) {
     Expression expression = node.expression;
     Type2 type = getStaticType(expression);
     if (type != null && type != _typeProvider.intType && type != _typeProvider.stringType) {
       Element element = type.element;
       if (element is ClassElement) {
         ClassElement classElement = element as ClassElement;
         MethodElement method = classElement.lookUpMethod("==", _currentLibrary);
         if (method != null && method.enclosingElement.type != _typeProvider.objectType) {
           _errorReporter.reportError2(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, expression, [element.displayName]);
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed method declaration is abstract only if the enclosing class is
    * also abstract.
    * @param node the method declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONCRETE_CLASS_WITH_ABSTRACT_MEMBER
    */
   bool checkForConcreteClassWithAbstractMember(MethodDeclaration node) {
     if (node.isAbstract() && _enclosingClass != null && !_enclosingClass.isAbstract()) {
       SimpleIdentifier methodName = node.name;
       _errorReporter.reportError2(StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER, methodName, [methodName.name, _enclosingClass.displayName]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies all possible conflicts of the constructor name with other constructors and
    * members of the same class.
    * @param node the constructor declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DUPLICATE_CONSTRUCTOR_DEFAULT
    * @see CompileTimeErrorCode#DUPLICATE_CONSTRUCTOR_NAME
    * @see CompileTimeErrorCode#CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD
    * @see CompileTimeErrorCode#CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD
    */
   bool checkForConflictingConstructorNameAndMember(ConstructorDeclaration node) {
     ConstructorElement constructorElement = node.element;
     SimpleIdentifier constructorName = node.name;
     String name = constructorElement.name;
     ClassElement classElement = constructorElement.enclosingElement;
@@ skipping 27 matching lines @@
         }
       }
     }
     return false;
   }
 
   /**
    * This verifies that the superclass of the enclosing class does not declare accessible static
    * member with the same name as the passed instance getter/setter method declaration.
    * @param node the method declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_INSTANCE_GETTER_AND_SUPERCLASS_MEMBER
    * @see StaticWarningCode#CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER
    */
   bool checkForConflictingInstanceGetterAndSuperclassMember(MethodDeclaration node) {
     if (node.isStatic()) {
       return false;
     }
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
@@ skipping 24 matching lines @@
     } else {
       _errorReporter.reportError2(StaticWarningCode.CONFLICTING_INSTANCE_SETTER_AND_SUPERCLASS_MEMBER, nameNode, [superElementType.displayName]);
     }
     return true;
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    * @param node the method declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER
    */
   bool checkForConflictingStaticGetterAndInstanceSetter(MethodDeclaration node) {
     if (!node.isStatic()) {
       return false;
     }
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
@@ skipping 12 matching lines @@
     ClassElement setterClass = setter.enclosingElement as ClassElement;
     InterfaceType setterType = setterClass.type;
     _errorReporter.reportError2(StaticWarningCode.CONFLICTING_STATIC_GETTER_AND_INSTANCE_SETTER, nameNode, [setterType.displayName]);
     return true;
   }
 
   /**
    * This verifies that the enclosing class does not have an instance member with the same name as
    * the passed static getter method declaration.
    * @param node the method declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER
    */
   bool checkForConflictingStaticSetterAndInstanceMember(MethodDeclaration node) {
     if (!node.isStatic()) {
       return false;
     }
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
       return false;
     }
@@ skipping 19 matching lines @@
     ClassElement memberClass = member.enclosingElement as ClassElement;
     InterfaceType memberType = memberClass.type;
     _errorReporter.reportError2(StaticWarningCode.CONFLICTING_STATIC_SETTER_AND_INSTANCE_MEMBER, nameNode, [memberType.displayName]);
     return true;
   }
 
   /**
    * This verifies that the passed constructor declaration is 'const' then there are no non-final
    * instance variable.
    * @param node the constructor declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD
    */
   bool checkForConstConstructorWithNonFinalField(ConstructorDeclaration node) {
     if (!_isEnclosingConstructorConst) {
       return false;
     }
     ConstructorElement constructorElement = node.element;
     ClassElement classElement = constructorElement.enclosingElement;
     if (!classElement.hasNonFinalField()) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD, node, []);
     return true;
   }
 
   /**
    * This verifies that the passed throw expression is not enclosed in a 'const' constructor
    * declaration.
    * @param node the throw expression expression to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_CONSTRUCTOR_THROWS_EXCEPTION
    */
   bool checkForConstEvalThrowsException(ThrowExpression node) {
     if (_isEnclosingConstructorConst) {
       _errorReporter.reportError2(CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed normal formal parameter is not 'const'.
    * @param node the normal formal parameter to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_FORMAL_PARAMETER
    */
   bool checkForConstFormalParameter(NormalFormalParameter node) {
     if (node.isConst()) {
       _errorReporter.reportError2(CompileTimeErrorCode.CONST_FORMAL_PARAMETER, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed instance creation expression is not being invoked on an abstract
    * class.
    * @param node the instance creation expression to evaluate
-   * @param typeName the {@link TypeName} of the {@link ConstructorName} from the{@link InstanceCreationExpression}, this is the AST node that the error is attached to
-   * @param type the type being constructed with this {@link InstanceCreationExpression}
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param typeName the [TypeName] of the [ConstructorName] from the[InstanceCreationExpression], this is the AST node that the error is attached to
+   * @param type the type being constructed with this [InstanceCreationExpression]
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#CONST_WITH_ABSTRACT_CLASS
    * @see StaticWarningCode#NEW_WITH_ABSTRACT_CLASS
    */
   bool checkForConstOrNewWithAbstractClass(InstanceCreationExpression node, TypeName typeName, InterfaceType type) {
     if (type.element.isAbstract()) {
       ConstructorElement element = node.element;
       if (element != null && !element.isFactory()) {
         if (identical(((node.keyword as sc.KeywordToken)).keyword, sc.Keyword.CONST)) {
           _errorReporter.reportError2(StaticWarningCode.CONST_WITH_ABSTRACT_CLASS, typeName, []);
         } else {
           _errorReporter.reportError2(StaticWarningCode.NEW_WITH_ABSTRACT_CLASS, typeName, []);
         }
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed 'const' instance creation expression is not being invoked on a
    * constructor that is not 'const'.
-   * <p>
+   *
    * This method assumes that the instance creation was tested to be 'const' before being called.
    * @param node the instance creation expression to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_NON_CONST
    */
   bool checkForConstWithNonConst(InstanceCreationExpression node) {
     ConstructorElement constructorElement = node.element;
     if (constructorElement != null && !constructorElement.isConst()) {
       _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_NON_CONST, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed 'const' instance creation expression does not reference any type
    * parameters.
-   * <p>
+   *
    * This method assumes that the instance creation was tested to be 'const' before being called.
    * @param node the instance creation expression to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_TYPE_PARAMETERS
    */
   bool checkForConstWithTypeParameters(InstanceCreationExpression node) {
     ConstructorName constructorName = node.constructorName;
     if (constructorName == null) {
       return false;
     }
     TypeName typeName = constructorName.type;
     return checkForConstWithTypeParameters2(typeName);
   }
 
   /**
    * This verifies that the passed type name does not reference any type parameters.
    * @param typeName the type name to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_TYPE_PARAMETERS
    */
   bool checkForConstWithTypeParameters2(TypeName typeName) {
     if (typeName == null) {
       return false;
     }
     Identifier name = typeName.name;
     if (name == null) {
       return false;
     }
     if (name.element is TypeVariableElement) {
       _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS, name, []);
     }
     TypeArgumentList typeArguments = typeName.typeArguments;
     if (typeArguments != null) {
       bool hasError = false;
       for (TypeName argument in typeArguments.arguments) {
         hasError = javaBooleanOr(hasError, checkForConstWithTypeParameters2(argument));
       }
       return hasError;
     }
     return false;
   }
 
   /**
    * This verifies that if the passed 'const' instance creation expression is being invoked on the
    * resolved constructor.
-   * <p>
+   *
    * This method assumes that the instance creation was tested to be 'const' before being called.
    * @param node the instance creation expression to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_WITH_UNDEFINED_CONSTRUCTOR
    * @see CompileTimeErrorCode#CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT
    */
   bool checkForConstWithUndefinedConstructor(InstanceCreationExpression node) {
     if (node.element != null) {
       return false;
     }
     ConstructorName constructorName = node.constructorName;
     if (constructorName == null) {
       return false;
     }
     TypeName type = constructorName.type;
     if (type == null) {
       return false;
     }
     Identifier className = type.name;
     SimpleIdentifier name = constructorName.name;
     if (name != null) {
       _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR, name, [className, name]);
     } else {
       _errorReporter.reportError2(CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT, constructorName, [className]);
     }
     return true;
   }
 
   /**
    * This verifies that there are no default parameters in the passed function type alias.
    * @param node the function type alias to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS
    */
   bool checkForDefaultValueInFunctionTypeAlias(FunctionTypeAlias node) {
     bool result = false;
     FormalParameterList formalParameterList = node.parameters;
     NodeList<FormalParameter> parameters = formalParameterList.parameters;
     for (FormalParameter formalParameter in parameters) {
       if (formalParameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultFormalParameter = formalParameter as DefaultFormalParameter;
         if (defaultFormalParameter.defaultValue != null) {
           _errorReporter.reportError2(CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS, node, []);
           result = true;
         }
       }
     }
     return result;
   }
 
   /**
    * This verifies the passed import has unique name among other exported libraries.
    * @param node the export directive to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#EXPORT_DUPLICATED_LIBRARY_NAME
    */
   bool checkForExportDuplicateLibraryName(ExportDirective node) {
     Element nodeElement = node.element;
     if (nodeElement is! ExportElement) {
       return false;
     }
     ExportElement nodeExportElement = nodeElement as ExportElement;
     LibraryElement nodeLibrary = nodeExportElement.exportedLibrary;
     if (nodeLibrary == null) {
       return false;
     }
     String name = nodeLibrary.name;
     LibraryElement prevLibrary = _nameToExportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != nodeLibrary) {
         _errorReporter.reportError2(StaticWarningCode.EXPORT_DUPLICATED_LIBRARY_NAME, node, [prevLibrary.definingCompilationUnit.displayName, nodeLibrary.definingCompilationUnit.displayName, name]);
         return true;
       }
     } else {
       _nameToExportElement[name] = nodeLibrary;
     }
     return false;
   }
 
   /**
    * Check that if the visiting library is not system, then any passed library should not be SDK
    * internal library.
    * @param node the export directive to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#EXPORT_INTERNAL_LIBRARY
    */
   bool checkForExportInternalLibrary(ExportDirective node) {
     if (_isInSystemLibrary) {
       return false;
     }
     Element element = node.element;
     if (element is! ExportElement) {
       return false;
     }
     ExportElement exportElement = element as ExportElement;
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = exportElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal()) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
    * This verifies that the passed extends clause does not extend classes such as num or String.
    * @param node the extends clause to test
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
    */
   bool checkForExtendsDisallowedClass(ExtendsClause extendsClause) {
     if (extendsClause == null) {
       return false;
     }
     return checkForExtendsOrImplementsDisallowedClass(extendsClause.superclass, CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS);
   }
 
   /**
    * This verifies that the passed type name does not extend or implement classes such as 'num' or
    * 'String'.
    * @param node the type name to test
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see #checkForExtendsDisallowedClass(ExtendsClause)
    * @see #checkForImplementsDisallowedClass(ImplementsClause)
    * @see CompileTimeErrorCode#EXTENDS_DISALLOWED_CLASS
    * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
    */
   bool checkForExtendsOrImplementsDisallowedClass(TypeName typeName, ErrorCode errorCode) {
     if (typeName.isSynthetic()) {
       return false;
     }
     Type2 superType = typeName.type;
@@ skipping 13 matching lines @@
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed constructor field initializer has compatible field and
    * initializer expression types.
    * @param node the constructor field initializer to test
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE
    * @see StaticWarningCode#FIELD_INITIALIZER_NOT_ASSIGNABLE
    */
   bool checkForFieldInitializerNotAssignable(ConstructorFieldInitializer node) {
     Element fieldNameElement = node.fieldName.element;
     if (fieldNameElement is! FieldElement) {
       return false;
     }
     FieldElement fieldElement = fieldNameElement as FieldElement;
     Type2 fieldType = fieldElement.type;
@@ skipping 23 matching lines @@
       _errorReporter.reportError2(CompileTimeErrorCode.CONST_FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [(propagatedType == null ? staticType : propagatedType).displayName, fieldType.displayName]);
     } else {
       _errorReporter.reportError2(StaticWarningCode.FIELD_INITIALIZER_NOT_ASSIGNABLE, expression, [(propagatedType == null ? staticType : propagatedType).displayName, fieldType.displayName]);
     }
     return true;
   }
 
   /**
    * This verifies that the passed field formal parameter is in a constructor declaration.
    * @param node the field formal parameter to test
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR
    */
   bool checkForFieldInitializingFormalRedirectingConstructor(FieldFormalParameter node) {
     ConstructorDeclaration constructor = node.getAncestor(ConstructorDeclaration);
     if (constructor == null) {
       _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR, node, []);
       return true;
     }
     if (constructor.factoryKeyword != null) {
       _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZER_FACTORY_CONSTRUCTOR, node, []);
       return true;
     }
     for (ConstructorInitializer initializer in constructor.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         _errorReporter.reportError2(CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR, node, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that final fields that are declared, without any constructors in the enclosing
    * class, are initialized. Cases in which there is at least one constructor are handled at the end
-   * of {@link #checkForAllFinalInitializedErrorCodes(ConstructorDeclaration)}.
+   * of [checkForAllFinalInitializedErrorCodes].
    * @param node the class declaration to test
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FINAL_NOT_INITIALIZED
    */
   bool checkForFinalNotInitialized(ClassDeclaration node) {
     NodeList<ClassMember> classMembers = node.members;
     for (ClassMember classMember in classMembers) {
       if (classMember is ConstructorDeclaration) {
         return false;
       }
     }
     bool foundError = false;
     for (ClassMember classMember in classMembers) {
       if (classMember is FieldDeclaration) {
         FieldDeclaration field = classMember as FieldDeclaration;
         foundError = javaBooleanOr(foundError, checkForFinalNotInitialized2(field.fields));
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the passed variable declaration list has only initialized variables if the
-   * list is final or const. This method is called by{@link #checkForFinalNotInitialized(ClassDeclaration)},{@link #visitTopLevelVariableDeclaration(TopLevelVariableDeclaration)} and{@link #visitVariableDeclarationStatement(VariableDeclarationStatement)}.
+   * list is final or const. This method is called by[checkForFinalNotInitialized],[visitTopLevelVariableDeclaration] and[visitVariableDeclarationStatement].
    * @param node the class declaration to test
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#FINAL_NOT_INITIALIZED
    */
   bool checkForFinalNotInitialized2(VariableDeclarationList node) {
     bool foundError = false;
     if (!node.isSynthetic() && (node.isConst() || node.isFinal())) {
       NodeList<VariableDeclaration> variables = node.variables;
       for (VariableDeclaration variable in variables) {
         if (variable.initializer == null) {
           _errorReporter.reportError2(StaticWarningCode.FINAL_NOT_INITIALIZED, variable, [variable.name.name]);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that the passed implements clause does not implement classes such as 'num' or
    * 'String'.
    * @param node the implements clause to test
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPLEMENTS_DISALLOWED_CLASS
    */
   bool checkForImplementsDisallowedClass(ImplementsClause implementsClause) {
     if (implementsClause == null) {
       return false;
     }
     bool foundError = false;
     for (TypeName type in implementsClause.interfaces) {
       foundError = javaBooleanOr(foundError, checkForExtendsOrImplementsDisallowedClass(type, CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS));
     }
     return foundError;
   }
 
   /**
    * This verifies that if the passed identifier is part of constructor initializer, then it does
    * not reference implicitly 'this' expression.
    * @param node the simple identifier to test
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPLICIT_THIS_REFERENCE_IN_INITIALIZER
    */
   bool checkForImplicitThisReferenceInInitializer(SimpleIdentifier node) {
     if (!_isInConstructorInitializer) {
       return false;
     }
     Element element = node.element;
     if (!(element is MethodElement || element is PropertyAccessorElement)) {
       return false;
     }
@@ skipping 26 matching lines @@
         }
       }
     }
     _errorReporter.reportError2(CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER, node, []);
     return true;
   }
 
   /**
    * This verifies the passed import has unique name among other imported libraries.
    * @param node the import directive to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPORT_DUPLICATED_LIBRARY_NAME
    */
   bool checkForImportDuplicateLibraryName(ImportDirective node) {
     Element nodeElement = node.element;
     if (nodeElement is! ImportElement) {
       return false;
     }
     ImportElement nodeImportElement = nodeElement as ImportElement;
     LibraryElement nodeLibrary = nodeImportElement.importedLibrary;
     if (nodeLibrary == null) {
       return false;
     }
     String name = nodeLibrary.name;
     LibraryElement prevLibrary = _nameToImportElement[name];
     if (prevLibrary != null) {
       if (prevLibrary != nodeLibrary) {
         _errorReporter.reportError2(StaticWarningCode.IMPORT_DUPLICATED_LIBRARY_NAME, node, [prevLibrary.definingCompilationUnit.displayName, nodeLibrary.definingCompilationUnit.displayName, name]);
         return true;
       }
     } else {
       _nameToImportElement[name] = nodeLibrary;
     }
     return false;
   }
 
   /**
    * Check that if the visiting library is not system, then any passed library should not be SDK
    * internal library.
    * @param node the import directive to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#IMPORT_INTERNAL_LIBRARY
    */
   bool checkForImportInternalLibrary(ImportDirective node) {
     if (_isInSystemLibrary) {
       return false;
     }
     Element element = node.element;
     if (element is! ImportElement) {
       return false;
     }
     ImportElement importElement = element as ImportElement;
     DartSdk sdk = _currentLibrary.context.sourceFactory.dartSdk;
     String uri = importElement.uri;
     SdkLibrary sdkLibrary = sdk.getSdkLibrary(uri);
     if (sdkLibrary == null) {
       return false;
     }
     if (!sdkLibrary.isInternal()) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY, node, [node.uri]);
     return true;
   }
 
   /**
    * This verifies that the passed switch statement case expressions all have the same type.
    * @param node the switch statement to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#INCONSISTENT_CASE_EXPRESSION_TYPES
    */
   bool checkForInconsistentCaseExpressionTypes(SwitchStatement node) {
     NodeList<SwitchMember> switchMembers = node.members;
     bool foundError = false;
     Type2 firstType = null;
     for (SwitchMember switchMember in switchMembers) {
       if (switchMember is SwitchCase) {
         SwitchCase switchCase = switchMember as SwitchCase;
         Expression expression = switchCase.expression;
         if (firstType == null) {
           firstType = getBestType(expression);
         } else {
           Type2 nType = getBestType(expression);
           if (firstType != nType) {
             _errorReporter.reportError2(CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES, expression, [expression.toSource(), firstType.displayName]);
             foundError = true;
           }
         }
       }
     }
     return foundError;
   }
 
   /**
    * For each class declaration, this method is called which verifies that all inherited members are
    * inherited consistently.
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INCONSISTENT_METHOD_INHERITANCE
    */
   bool checkForInconsistentMethodInheritance() {
     _inheritanceManager.getMapOfMembersInheritedFromInterfaces(_enclosingClass);
     Set<AnalysisError> errors = _inheritanceManager.getErrors(_enclosingClass);
     if (errors == null || errors.isEmpty) {
       return false;
     }
     for (AnalysisError error in errors) {
       _errorReporter.reportError(error);
     }
     return true;
   }
 
   /**
    * Given an assignment using a compound assignment operator, this verifies that the given
    * assignment is valid.
    * @param node the assignment expression being tested
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
   bool checkForInvalidAssignment(AssignmentExpression node) {
     Expression lhs = node.leftHandSide;
     if (lhs == null) {
       return false;
     }
     VariableElement leftElement = getVariableElement(lhs);
     Type2 leftType = (leftElement == null) ? getStaticType(lhs) : leftElement.type;
     MethodElement invokedMethod = node.element;
     if (invokedMethod == null) {
       return false;
     }
     Type2 rightType = invokedMethod.type.returnType;
     if (leftType == null || rightType == null) {
       return false;
     }
     if (!rightType.isAssignableTo(leftType)) {
       _errorReporter.reportError2(StaticTypeWarningCode.INVALID_ASSIGNMENT, node.rightHandSide, [rightType.displayName, leftType.displayName]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed left hand side and right hand side represent a valid assignment.
    * @param lhs the left hand side expression
    * @param rhs the right hand side expression
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INVALID_ASSIGNMENT
    */
   bool checkForInvalidAssignment2(Expression lhs, Expression rhs) {
     if (lhs == null || rhs == null) {
       return false;
     }
     VariableElement leftElement = getVariableElement(lhs);
     Type2 leftType = (leftElement == null) ? getStaticType(lhs) : leftElement.type;
     Type2 staticRightType = getStaticType(rhs);
     bool isStaticAssignable = staticRightType.isAssignableTo(leftType);
     Type2 propagatedRightType = getPropagatedType(rhs);
     if (_strictMode || propagatedRightType == null) {
       if (!isStaticAssignable) {
         _errorReporter.reportError2(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [staticRightType.displayName, leftType.displayName]);
         return true;
       }
     } else {
       bool isPropagatedAssignable = propagatedRightType.isAssignableTo(leftType);
       if (!isStaticAssignable && !isPropagatedAssignable) {
         _errorReporter.reportError2(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [staticRightType.displayName, leftType.displayName]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the usage of the passed 'this' is valid.
    * @param node the 'this' expression to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#INVALID_REFERENCE_TO_THIS
    */
   bool checkForInvalidReferenceToThis(ThisExpression node) {
     if (!isThisInValidContext(node)) {
       _errorReporter.reportError2(CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * Checks to ensure that first type argument to a map literal must be the 'String' type.
-   * @param arguments a non-{@code null}, non-empty {@link TypeName} node list from the respective{@link MapLiteral}
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param arguments a non-`null`, non-empty [TypeName] node list from the respective[MapLiteral]
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_FOR_KEY
    */
   bool checkForInvalidTypeArgumentForKey(NodeList<TypeName> arguments) {
     TypeName firstArgument = arguments[0];
     Type2 firstArgumentType = firstArgument.type;
     if (firstArgumentType != null && firstArgumentType != _typeProvider.stringType) {
       _errorReporter.reportError2(CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_FOR_KEY, firstArgument, []);
       return true;
     }
     return false;
   }
 
   /**
-   * Checks to ensure that the passed {@link ListLiteral} or {@link MapLiteral} does not have a type
+   * Checks to ensure that the passed [ListLiteral] or [MapLiteral] does not have a type
    * parameter as a type argument.
-   * @param arguments a non-{@code null}, non-empty {@link TypeName} node list from the respective{@link ListLiteral} or {@link MapLiteral}
-   * @param errorCode either {@link CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_IN_CONST_LIST} or{@link CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_IN_CONST_MAP}
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param arguments a non-`null`, non-empty [TypeName] node list from the respective[ListLiteral] or [MapLiteral]
+   * @param errorCode either [CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_IN_CONST_LIST] or[CompileTimeErrorCode#INVALID_TYPE_ARGUMENT_IN_CONST_MAP]
+   * @return `true` if and only if an error code is generated on the passed node
    */
   bool checkForInvalidTypeArgumentInConstTypedLiteral(NodeList<TypeName> arguments, ErrorCode errorCode) {
     bool foundError = false;
     for (TypeName typeName in arguments) {
       if (typeName.type is TypeVariableType) {
         _errorReporter.reportError2(errorCode, typeName, [typeName.name]);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
-   * This verifies that the {@link #enclosingClass} does not define members with the same name as
+   * This verifies that the [enclosingClass] does not define members with the same name as
    * the enclosing class.
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MEMBER_WITH_CLASS_NAME
    */
   bool checkForMemberWithClassName() {
     if (_enclosingClass == null) {
       return false;
     }
     String className = _enclosingClass.name;
     if (className == null) {
       return false;
     }
@@ skipping 35 matching lines @@
     }
     if (setterType != null && getterType != null && !getterType.isAssignableTo(setterType)) {
       _errorReporter.reportError2(StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES, accessorDeclaration, [accessorTextName, setterType.displayName, getterType.displayName]);
     }
   }
 
   /**
    * This verifies that the passed mixin does not have an explicitly declared constructor.
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_DECLARES_CONSTRUCTOR
    */
   bool checkForMixinDeclaresConstructor(TypeName mixinName, ClassElement mixinElement) {
     for (ConstructorElement constructor in mixinElement.constructors) {
       if (!constructor.isSynthetic() && !constructor.isFactory()) {
         _errorReporter.reportError2(CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR, mixinName, [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin has the 'Object' superclass.
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_INHERITS_FROM_NOT_OBJECT
    */
   bool checkForMixinInheritsNotFromObject(TypeName mixinName, ClassElement mixinElement) {
     InterfaceType mixinSupertype = mixinElement.supertype;
     if (mixinSupertype != null) {
       if (!mixinSupertype.isObject() || !mixinElement.isTypedef() && mixinElement.mixins.length != 0) {
         _errorReporter.reportError2(CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, mixinName, [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin does not reference 'super'.
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MIXIN_REFERENCES_SUPER
    */
   bool checkForMixinReferencesSuper(TypeName mixinName, ClassElement mixinElement) {
     if (mixinElement.hasReferenceToSuper()) {
       _errorReporter.reportError2(CompileTimeErrorCode.MIXIN_REFERENCES_SUPER, mixinName, [mixinElement.name]);
     }
     return false;
   }
 
   /**
    * This verifies that the passed constructor has at most one 'super' initializer.
    * @param node the constructor declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MULTIPLE_SUPER_INITIALIZERS
    */
   bool checkForMultipleSuperInitializers(ConstructorDeclaration node) {
     int numSuperInitializers = 0;
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is SuperConstructorInvocation) {
         numSuperInitializers++;
         if (numSuperInitializers > 1) {
           _errorReporter.reportError2(CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS, initializer, []);
         }
       }
     }
     return numSuperInitializers > 0;
   }
 
   /**
    * Checks to ensure that native function bodies can only in SDK code.
    * @param node the native function body to test
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see ParserErrorCode#NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE
    */
   bool checkForNativeFunctionBodyInNonSDKCode(NativeFunctionBody node) {
     if (!_isInSystemLibrary) {
       _errorReporter.reportError2(ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE, node, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed 'new' instance creation expression invokes existing constructor.
-   * <p>
+   *
    * This method assumes that the instance creation was tested to be 'new' before being called.
    * @param node the instance creation expression to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NEW_WITH_UNDEFINED_CONSTRUCTOR
    */
   bool checkForNewWithUndefinedConstructor(InstanceCreationExpression node) {
     if (node.element != null) {
       return false;
     }
     ConstructorName constructorName = node.constructorName;
     if (constructorName == null) {
       return false;
     }
     TypeName type = constructorName.type;
     if (type == null) {
       return false;
     }
     Identifier className = type.name;
     SimpleIdentifier name = constructorName.name;
     if (name != null) {
       _errorReporter.reportError2(StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR, name, [className, name]);
     } else {
       _errorReporter.reportError2(StaticWarningCode.NEW_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT, constructorName, [className]);
     }
     return true;
   }
 
   /**
+   * This checks that passed if the passed class declaration implicitly calls default constructor of
+   * its superclass, there should be such default constructor - implicit or explicit.
+   * @param node the [ClassDeclaration] to evaluate
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see StaticWarningCode#NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT
+   */
+  bool checkForNoDefaultSuperConstructorImplicit(ClassDeclaration node) {
+    List<ConstructorElement> constructors = _enclosingClass.constructors;
+    if (!constructors[0].isSynthetic()) {
+      return false;
+    }
+    InterfaceType superType = _enclosingClass.supertype;
+    if (superType == null) {
+      return false;
+    }
+    ClassElement superClass = superType.element;
+    if (superClass.hasDefaultConstructor()) {
+      return false;
+    }
+    _errorReporter.reportError2(StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT, node.name, [superType.displayName]);
+    return true;
+  }
+
+  /**
    * This checks that passed class declaration overrides all members required by its superclasses
    * and interfaces.
-   * @param node the {@link ClassDeclaration} to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param node the [ClassDeclaration] to evaluate
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR
    * @see StaticWarningCode#NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS
    */
   bool checkForNonAbstractClassInheritsAbstractMember(ClassDeclaration node) {
     if (_enclosingClass.isAbstract()) {
       return false;
     }
@@ skipping 80 matching lines @@
     }
     analysisError.setProperty(ErrorProperty.UNIMPLEMENTED_METHODS, missingOverridesArray);
     _errorReporter.reportError(analysisError);
     return true;
   }
 
   /**
    * Checks to ensure that the expressions that need to be of type bool, are. Otherwise an error is
    * reported on the expression.
    * @param condition the conditional expression to test
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#NON_BOOL_CONDITION
    */
   bool checkForNonBoolCondition(Expression condition) {
     Type2 conditionType = getStaticType(condition);
     if (conditionType != null && !conditionType.isAssignableTo(_typeProvider.boolType)) {
       _errorReporter.reportError2(StaticTypeWarningCode.NON_BOOL_CONDITION, condition, []);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed assert statement has either a 'bool' or '() -> bool' input.
    * @param node the assert statement to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#NON_BOOL_EXPRESSION
    */
   bool checkForNonBoolExpression(AssertStatement node) {
     Expression expression = node.condition;
     Type2 type = getStaticType(expression);
     if (type is InterfaceType) {
       if (!type.isAssignableTo(_typeProvider.boolType)) {
         _errorReporter.reportError2(StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression, []);
         return true;
       }
     } else if (type is FunctionType) {
       FunctionType functionType = type as FunctionType;
       if (functionType.typeArguments.length == 0 && !functionType.returnType.isAssignableTo(_typeProvider.boolType)) {
         _errorReporter.reportError2(StaticTypeWarningCode.NON_BOOL_EXPRESSION, expression, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies the passed map literal either:
-   * <ul>
-   * <li>has {@code const modifier}</li>
-   * <li>has explicit type arguments</li>
-   * <li>is not start of the statement</li>
-   * <ul>
+   *
+   * * has `const modifier`
+   * * has explicit type arguments
+   * * is not start of the statement
+   *
    * @param node the map literal to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#NON_CONST_MAP_AS_EXPRESSION_STATEMENT
    */
   bool checkForNonConstMapAsExpressionStatement(MapLiteral node) {
     if (node.modifier != null) {
       return false;
     }
     if (node.typeArguments != null) {
       return false;
     }
     Statement statement = node.getAncestor(ExpressionStatement);
     if (statement == null) {
       return false;
     }
     if (statement.beginToken != node.beginToken) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT, node, []);
     return true;
   }
 
   /**
-   * This verifies the passed method declaration of operator {@code \[\]=}, has {@code void} return
+   * This verifies the passed method declaration of operator `\[\]=`, has `void` return
    * type.
    * @param node the method declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_VOID_RETURN_FOR_OPERATOR
    */
   bool checkForNonVoidReturnTypeForOperator(MethodDeclaration node) {
     SimpleIdentifier name = node.name;
     if (name.name != "[]=") {
       return false;
     }
     TypeName typeName = node.returnType;
     if (typeName != null) {
       Type2 type = typeName.type;
       if (type != null && !type.isVoid()) {
         _errorReporter.reportError2(StaticWarningCode.NON_VOID_RETURN_FOR_OPERATOR, typeName, []);
       }
     }
     return false;
   }
 
   /**
-   * This verifies the passed setter has no return type or the {@code void} return type.
+   * This verifies the passed setter has no return type or the `void` return type.
    * @param typeName the type name to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#NON_VOID_RETURN_FOR_SETTER
    */
   bool checkForNonVoidReturnTypeForSetter(TypeName typeName) {
     if (typeName != null) {
       Type2 type = typeName.type;
       if (type != null && !type.isVoid()) {
         _errorReporter.reportError2(StaticWarningCode.NON_VOID_RETURN_FOR_SETTER, typeName, []);
       }
     }
     return false;
   }
 
   /**
    * This verifies the passed operator-method declaration, does not have an optional parameter.
-   * <p>
+   *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
    * @param node the method declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#OPTIONAL_PARAMETER_IN_OPERATOR
    */
   bool checkForOptionalParameterInOperator(MethodDeclaration node) {
     FormalParameterList parameterList = node.parameters;
     if (parameterList == null) {
       return false;
     }
     bool foundError = false;
     NodeList<FormalParameter> formalParameters = parameterList.parameters;
     for (FormalParameter formalParameter in formalParameters) {
       if (formalParameter.kind.isOptional()) {
         _errorReporter.reportError2(CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR, formalParameter, []);
         foundError = true;
       }
     }
     return foundError;
   }
 
   /**
    * This checks for named optional parameters that begin with '_'.
    * @param node the default formal parameter to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#PRIVATE_OPTIONAL_PARAMETER
    */
   bool checkForPrivateOptionalParameter(DefaultFormalParameter node) {
     sc.Token separator = node.separator;
     if (separator != null && separator.lexeme == ":") {
       NormalFormalParameter parameter = node.parameter;
       SimpleIdentifier name = parameter.identifier;
       if (!name.isSynthetic() && name.name.startsWith("_")) {
         _errorReporter.reportError2(CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER, node, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This checks if the passed constructor declaration is the redirecting generative constructor and
    * references itself directly or indirectly.
    * @param node the constructor declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RECURSIVE_CONSTRUCTOR_REDIRECT
    */
   bool checkForRecursiveConstructorRedirect(ConstructorDeclaration node) {
     if (node.factoryKeyword != null) {
       return false;
     }
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         ConstructorElement element = node.element;
         if (!hasRedirectingFactoryConstructorCycle(element)) {
           return false;
         }
         _errorReporter.reportError2(CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT, initializer, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This checks if the passed constructor declaration has redirected constructor and references
    * itself directly or indirectly.
    * @param node the constructor declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#RECURSIVE_FACTORY_REDIRECT
    */
   bool checkForRecursiveFactoryRedirect(ConstructorDeclaration node) {
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     ConstructorElement element = node.element;
     if (!hasRedirectingFactoryConstructorCycle(element)) {
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT, redirectedConstructorNode, []);
     return true;
   }
 
   /**
    * This checks the class declaration is not a superinterface to itself.
    * @param classElt the class element to test
    * @param list a list containing the potentially cyclic implements path
-   * @return {@code true} if and only if an error code is generated on the passed element
+   * @return `true` if and only if an error code is generated on the passed element
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS
    * @see CompileTimeErrorCode#RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS
    */
   bool checkForRecursiveInterfaceInheritance(ClassElement classElt, List<ClassElement> list) {
     if (classElt == null) {
       return false;
     }
     InterfaceType supertype = classElt.supertype;
     list.add(classElt);
@@ skipping 43 matching lines @@
       }
     }
     list.removeAt(list.length - 1);
     return false;
   }
 
   /**
    * This checks the passed constructor declaration has a valid combination of redirected
    * constructor invocation(s), super constructor invocations and field initializers.
    * @param node the constructor declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS
    * @see CompileTimeErrorCode#SUPER_IN_REDIRECTING_CONSTRUCTOR
    * @see CompileTimeErrorCode#FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR
    */
   bool checkForRedirectingConstructorErrorCodes(ConstructorDeclaration node) {
     int numProblems = 0;
     int numRedirections = 0;
     for (ConstructorInitializer initializer in node.initializers) {
       if (initializer is RedirectingConstructorInvocation) {
         if (numRedirections > 0) {
@@ skipping 15 matching lines @@
         }
       }
     }
     return numProblems != 0;
   }
 
   /**
    * This checks if the passed constructor declaration has redirected constructor and references
    * itself directly or indirectly. TODO(scheglov)
    * @param node the constructor declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#REDIRECT_TO_NON_CONST_CONSTRUCTOR
    */
   bool checkForRedirectToNonConstConstructor(ConstructorDeclaration node) {
     ConstructorName redirectedConstructorNode = node.redirectedConstructor;
     if (redirectedConstructorNode == null) {
       return false;
     }
     ConstructorElement element = node.element;
     if (element == null) {
       return false;
     }
     if (!element.isConst()) {
       return false;
     }
     ConstructorElement redirectedConstructor = element.redirectedConstructor;
     if (redirectedConstructor == null) {
       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 {@code true} if and only if an error code is generated on the passed node
+   * @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;
       }
     }
@@ skipping 25 matching lines @@
     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 {@code true} if and only if an error code is generated on the passed node
+   * @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;
     }
     return false;
   }
 
   /**
+   * This checks that a type mis-match between the return type and the expressed return type by the
+   * enclosing method or function.
+   *
+   * This method is called both by [checkForAllReturnStatementErrorCodes]and [visitExpressionFunctionBody].
+   * @param returnExpression the returned expression to evaluate
+   * @param expectedReturnType the expressed return type by the enclosing method or function
+   * @return `true` if and only if an error code is generated on the passed node
+   * @see StaticTypeWarningCode#RETURN_OF_INVALID_TYPE
+   */
+  bool checkForReturnOfInvalidType(Expression returnExpression, Type2 expectedReturnType) {
+    Type2 staticReturnType = getStaticType(returnExpression);
+    if (expectedReturnType.isVoid()) {
+      if (staticReturnType.isVoid() || staticReturnType.isDynamic() || identical(staticReturnType, BottomTypeImpl.instance)) {
+        return false;
+      }
+      _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [staticReturnType.displayName, expectedReturnType.displayName, _enclosingFunction.displayName]);
+      return true;
+    }
+    bool isStaticAssignable = staticReturnType.isAssignableTo(expectedReturnType);
+    Type2 propagatedReturnType = getPropagatedType(returnExpression);
+    if (_strictMode || propagatedReturnType == null) {
+      if (isStaticAssignable) {
+        return false;
+      }
+      _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [staticReturnType.displayName, expectedReturnType.displayName, _enclosingFunction.displayName]);
+      return true;
+    } else {
+      bool isPropagatedAssignable = propagatedReturnType.isAssignableTo(expectedReturnType);
+      if (isStaticAssignable || isPropagatedAssignable) {
+        return false;
+      }
+      _errorReporter.reportError2(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [staticReturnType.displayName, expectedReturnType.displayName, _enclosingFunction.displayName]);
+      return true;
+    }
+  }
+
+  /**
    * This checks that if the given "target" is the type reference then the "name" is not the
    * reference to a instance member.
    * @param target the target of the name access to evaluate
    * @param name the accessed name to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#STATIC_ACCESS_TO_INSTANCE_MEMBER
    */
   bool checkForStaticAccessToInstanceMember(Expression target, SimpleIdentifier name2) {
     Element element = name2.element;
     if (element is! ExecutableElement) {
       return false;
     }
     ExecutableElement memberElement = element as ExecutableElement;
     if (memberElement.isStatic()) {
       return false;
     }
     if (!isTypeReference(target)) {
       return false;
     }
     _errorReporter.reportError2(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, name2, [name2.name]);
     return true;
   }
 
   /**
    * This checks that the type of the passed 'switch' expression is assignable to the type of the
    * 'case' members.
    * @param node the 'switch' statement to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#SWITCH_EXPRESSION_NOT_ASSIGNABLE
    */
   bool checkForSwitchExpressionNotAssignable(SwitchStatement node) {
     Expression expression = node.expression;
     Type2 expressionType = getStaticType(expression);
     if (expressionType == null) {
       return false;
     }
     NodeList<SwitchMember> members = node.members;
     for (SwitchMember switchMember in members) {
@@ skipping 10 matching lines @@
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the type arguments in the passed instance creation expression are all within
    * their bounds as specified by the class element where the constructor \[that is being invoked\] is
    * declared.
    * @param node the instance creation expression to evaluate
-   * @param typeName the {@link TypeName} of the {@link ConstructorName} from the{@link InstanceCreationExpression}, this is the AST node that the error is attached to
-   * @param constructorElement the {@link ConstructorElement} from the instance creation expression
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param typeName the [TypeName] of the [ConstructorName] from the[InstanceCreationExpression], this is the AST node that the error is attached to
+   * @param constructorElement the [ConstructorElement] from the instance creation expression
+   * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#TYPE_ARGUMENT_NOT_MATCHING_BOUNDS
    */
   bool checkForTypeArgumentNotMatchingBounds(InstanceCreationExpression node, ConstructorElement constructorElement, TypeName typeName) {
     if (typeName.typeArguments != null && constructorElement != null) {
       NodeList<TypeName> typeNameArgList = typeName.typeArguments.arguments;
       List<TypeVariableElement> boundingElts = constructorElement.enclosingElement.typeVariables;
       int loopThroughIndex = Math.min(typeNameArgList.length, boundingElts.length);
       for (int i = 0; i < loopThroughIndex; i++) {
         TypeName argTypeName = typeNameArgList[i];
         Type2 argType = argTypeName.type;
         Type2 boundType = boundingElts[i].bound;
         if (argType != null && boundType != null) {
           if (!argType.isSubtypeOf(boundType)) {
             _errorReporter.reportError2(StaticTypeWarningCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS, argTypeName, [argTypeName.name, boundingElts[i].displayName]);
             return true;
           }
         }
       }
     }
     return false;
   }
 
   /**
    * This checks that if the passed generative constructor has neither an explicit super constructor
    * invocation nor a redirecting constructor invocation, that the superclass has a default
    * generative constructor.
    * @param node the constructor declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT
    * @see CompileTimeErrorCode#NON_GENERATIVE_CONSTRUCTOR
+   * @see StaticWarningCode#NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT
    */
   bool checkForUndefinedConstructorInInitializerImplicit(ConstructorDeclaration node) {
     if (node.factoryKeyword != null) {
       return false;
     }
     for (ConstructorInitializer constructorInitializer in node.initializers) {
       if (constructorInitializer is SuperConstructorInvocation || constructorInitializer is RedirectingConstructorInvocation) {
         return false;
       }
     }
     if (_enclosingClass == null) {
       return false;
     }
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
-    ConstructorElement superDefaultConstructor = superElement.unnamedConstructor;
-    if (superDefaultConstructor != null) {
-      if (superDefaultConstructor.isFactory()) {
-        _errorReporter.reportError2(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.returnType, [superDefaultConstructor]);
+    ConstructorElement superUnnamedConstructor = superElement.unnamedConstructor;
+    if (superUnnamedConstructor != null) {
+      if (superUnnamedConstructor.isFactory()) {
+        _errorReporter.reportError2(CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.returnType, [superUnnamedConstructor]);
         return true;
       }
+      if (!superUnnamedConstructor.isDefaultConstructor()) {
+        int offset;
+        int length;
+        {
+          Identifier returnType = node.returnType;
+          SimpleIdentifier name = node.name;
+          offset = returnType.offset;
+          length = (name != null ? name.end : returnType.end) - offset;
+        }
+        _errorReporter.reportError3(StaticWarningCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT, offset, length, [superType.displayName]);
+      }
       return false;
     }
     _errorReporter.reportError2(CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT, node.returnType, [superElement.name]);
     return true;
   }
 
   /**
    * This verifies the passed operator-method declaration, has correct number of parameters.
-   * <p>
+   *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
    * @param node the method declaration to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR
    */
   bool checkForWrongNumberOfParametersForOperator(MethodDeclaration node) {
     FormalParameterList parameterList = node.parameters;
     if (parameterList == null) {
       return false;
     }
     int numParameters = parameterList.parameters.length;
     SimpleIdentifier nameNode = node.name;
     if (nameNode == null) {
@@ skipping 14 matching lines @@
     }
     if ("-" == name && numParameters > 1) {
       _errorReporter.reportError2(CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS, nameNode, [numParameters]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies if the passed setter parameter list have only one parameter.
-   * <p>
+   *
    * This method assumes that the method declaration was tested to be a setter before being called.
    * @param setterName the name of the setter to report problems on
    * @param parameterList the parameter list to evaluate
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER
    */
   bool checkForWrongNumberOfParametersForSetter(SimpleIdentifier setterName, FormalParameterList parameterList) {
     if (setterName == null) {
       return false;
     }
     if (parameterList == null) {
       return false;
     }
     int numberOfParameters = parameterList.parameters.length;
@@ skipping 59 matching lines @@
    */
   Type2 getStaticType(Expression expression) {
     Type2 type = expression.staticType;
     if (type == null) {
       return _dynamicType;
     }
     return type;
   }
 
   /**
-   * Return the variable element represented by the given expression, or {@code null} if there is no
+   * Return the variable element represented by the given expression, or `null` if there is no
    * such element.
    * @param expression the expression whose element is to be returned
    * @return the variable element represented by the expression
    */
   VariableElement getVariableElement(Expression expression) {
     if (expression is Identifier) {
       Element element = ((expression as Identifier)).element;
       if (element is VariableElement) {
         return element as VariableElement;
       }
     }
     return null;
   }
 
   /**
-   * @return {@code true} if the given constructor redirects to itself, directly or indirectly
+   * @return `true` if the given constructor redirects to itself, directly or indirectly
    */
   bool hasRedirectingFactoryConstructorCycle(ConstructorElement element) {
     Set<ConstructorElement> constructors = new Set<ConstructorElement>();
     ConstructorElement current = element;
     while (current != null) {
       if (constructors.contains(current)) {
         return identical(current, element);
       }
       javaSetAdd(constructors, current);
       current = current.redirectedConstructor;
       if (current is ConstructorMember) {
         current = ((current as ConstructorMember)).baseElement;
       }
     }
     return false;
   }
 
   /**
    * @param node the 'this' expression to analyze
-   * @return {@code true} if the given 'this' expression is in the valid context
+   * @return `true` if the given 'this' expression is in the valid context
    */
   bool isThisInValidContext(ThisExpression node) {
     for (ASTNode n = node; n != null; n = n.parent) {
       if (n is CompilationUnit) {
         return false;
       }
       if (n is ConstructorDeclaration) {
         ConstructorDeclaration constructor = n as ConstructorDeclaration;
         return constructor.factoryKeyword == null;
       }
@@ skipping 26 matching lines @@
 
   /// The position in the enum declaration.
   final int ordinal;
   INIT_STATE(this.name, this.ordinal) {
   }
   int compareTo(INIT_STATE other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }
 /**
- * Instances of the class {@code PubVerifier} traverse an AST structure looking for deviations from
+ * Instances of the class `PubVerifier` traverse an AST structure looking for deviations from
  * pub best practices.
  */
 class PubVerifier extends RecursiveASTVisitor<Object> {
   static String _PUBSPEC_YAML = "pubspec.yaml";
 
   /**
    * The analysis context containing the sources to be analyzed
    */
   AnalysisContext _context;
 
   /**
    * The error reporter by which errors will be reported.
    */
   ErrorReporter _errorReporter;
   PubVerifier(AnalysisContext context, ErrorReporter errorReporter) {
     this._context = context;
     this._errorReporter = errorReporter;
   }
   Object visitImportDirective(ImportDirective directive) {
     return null;
   }
 
   /**
    * This verifies that the passed file import directive is not contained in a source inside a
    * package "lib" directory hierarchy referencing a source outside that package "lib" directory
    * hierarchy.
-   * @param uriLiteral the import URL (not {@code null})
-   * @param path the file path being verified (not {@code null})
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param uriLiteral the import URL (not `null`)
+   * @param path the file path being verified (not `null`)
+   * @return `true` if and only if an error code is generated on the passed node
    * @see PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE
    */
   bool checkForFileImportInsideLibReferencesFileOutside(StringLiteral uriLiteral, String path) {
     Source source = getSource(uriLiteral);
     String fullName = getSourceFullName(source);
     if (fullName != null) {
       int pathIndex = 0;
       int fullNameIndex = fullName.length;
       while (pathIndex < path.length && JavaString.startsWithBefore(path, "../", pathIndex)) {
         fullNameIndex = fullName.lastIndexOf('/', fullNameIndex);
@@ skipping 11 matching lines @@
         pathIndex += 3;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed file import directive is not contained in a source outside a
    * package "lib" directory hierarchy referencing a source inside that package "lib" directory
    * hierarchy.
-   * @param uriLiteral the import URL (not {@code null})
-   * @param path the file path being verified (not {@code null})
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param uriLiteral the import URL (not `null`)
+   * @param path the file path being verified (not `null`)
+   * @return `true` if and only if an error code is generated on the passed node
    * @see PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE
    */
   bool checkForFileImportOutsideLibReferencesFileInside(StringLiteral uriLiteral, String path) {
     if (path.startsWith("lib/")) {
       if (checkForFileImportOutsideLibReferencesFileInside2(uriLiteral, path, 0)) {
         return true;
       }
     }
     int pathIndex = path.indexOf("/lib/");
     while (pathIndex != -1) {
@@ skipping 16 matching lines @@
       if (!fullName.contains("/lib/")) {
         _errorReporter.reportError2(PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE, uriLiteral, []);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed package import directive does not contain ".."
-   * @param uriLiteral the import URL (not {@code null})
-   * @param path the path to be validated (not {@code null})
-   * @return {@code true} if and only if an error code is generated on the passed node
+   * @param uriLiteral the import URL (not `null`)
+   * @param path the path to be validated (not `null`)
+   * @return `true` if and only if an error code is generated on the passed node
    * @see PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT
    */
   bool checkForPackageImportContainsDotDot(StringLiteral uriLiteral, String path) {
     if (path.startsWith("../") || path.contains("/../")) {
       _errorReporter.reportError2(PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT, uriLiteral, []);
       return true;
     }
     return false;
   }
 
   /**
    * Answer the source associated with the compilation unit containing the given AST node.
-   * @param node the node (not {@code null})
-   * @return the source or {@code null} if it could not be determined
+   * @param node the node (not `null`)
+   * @return the source or `null` if it could not be determined
    */
   Source getSource(ASTNode node) {
     Source source = null;
     CompilationUnit unit = node.getAncestor(CompilationUnit);
     if (unit != null) {
       CompilationUnitElement element = unit.element;
       if (element != null) {
         source = element.source;
       }
     }
     return source;
   }
 
   /**
-   * Answer the full name of the given source. The returned value will have all{@link File#separatorChar} replace by '/'.
+   * Answer the full name of the given source. The returned value will have all[File#separatorChar] replace by '/'.
    * @param source the source
-   * @return the full name or {@code null} if it could not be determined
+   * @return the full name or `null` if it could not be determined
    */
   String getSourceFullName(Source source) {
     if (source != null) {
       String fullName = source.fullName;
       if (fullName != null) {
         return fullName.replaceAll(r'\', '/');
       }
     }
     return null;
   }
 }
 /**
- * The enumeration {@code ResolverErrorCode} defines the error codes used for errors detected by the
+ * The enumeration `ResolverErrorCode` defines the error codes used for errors detected by the
  * resolver. The convention for this class is for the name of the error code to indicate the problem
  * that caused the error to be generated and for the error message to explain what is wrong and,
  * when appropriate, how the problem can be corrected.
  * @coverage dart.engine.resolver
  */
 class ResolverErrorCode implements Comparable<ResolverErrorCode>, ErrorCode {
   static final ResolverErrorCode BREAK_LABEL_ON_SWITCH_MEMBER = new ResolverErrorCode('BREAK_LABEL_ON_SWITCH_MEMBER', 0, ErrorType.COMPILE_TIME_ERROR, "Break label resolves to case or default statement");
   static final ResolverErrorCode CONTINUE_LABEL_ON_SWITCH = new ResolverErrorCode('CONTINUE_LABEL_ON_SWITCH', 1, ErrorType.COMPILE_TIME_ERROR, "A continue label resolves to switch, must be loop or switch member");
   static final ResolverErrorCode MISSING_LIBRARY_DIRECTIVE_WITH_PART = new ResolverErrorCode('MISSING_LIBRARY_DIRECTIVE_WITH_PART', 2, ErrorType.COMPILE_TIME_ERROR, "Libraries that have parts must have a library directive");
   static final List<ResolverErrorCode> values = [BREAK_LABEL_ON_SWITCH_MEMBER, CONTINUE_LABEL_ON_SWITCH, MISSING_LIBRARY_DIRECTIVE_WITH_PART];
@@ skipping 23 matching lines @@
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   int compareTo(ResolverErrorCode other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }