anchor.diff:        element.returnType = VoidTypeImpl.instance;
       }
     }
  -
  -  /**
  -   * Checks if the given type name is used as the type in an as expression.
  -   *
  -   * @param typeName the type name to analyzer
  -   * @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) {
  -      return identical(parent.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 `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) {
  -      return identical(parent.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 `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) {
  -      return parent != null && identical(parent.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 `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) {
  -      return identical(parent.type, typeName);
  -    }
  -    return false;
  -  }
  -
  -  /**
  -   * Checks if the given type name used in a type argument list.
  -   *
  -   * @param typeName the type name to analyzer
  -   * @return `true` if the given type name is in a type argument list
  -   */
  -  bool _isTypeNameInTypeArgumentList(TypeName typeName) =>
  -      typeName.parent is TypeArgumentList;
   
     /**
      * Record that the static type of the given node is the given type.
  
positive.code:   }
  
    /**
     * The number of type arguments in the given type name does not match the number of parameters in
     * the corresponding class element. Return the error code that should be used to report this
     * error.
     *
     * @param node the type name with the wrong number of type arguments
     * @return the error code that should be used to report that the wrong number of type arguments
     *         were provided
     */
    ErrorCode _getInvalidTypeParametersErrorCode(TypeName node) {
      AstNode parent = node.parent;
      if (parent is ConstructorName) {
        parent = parent.parent;
        if (parent is InstanceCreationExpression) {
          if (parent.isConst) {
            return CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS;
          } else {
            return StaticWarningCode.NEW_WITH_INVALID_TYPE_PARAMETERS;
          }
        }
      }
      return StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS;
    }
  
    /**
     * Checks if the given type name is the target in a redirected constructor.
     *
     * @param typeName the type name to analyze
     * @return some [RedirectingConstructorKind] if the given type name is used as the type in a
     *         redirected constructor, or `null` otherwise
     */
    RedirectingConstructorKind _getRedirectingConstructorKind(TypeName typeName) {
      AstNode parent = typeName.parent;
      if (parent is ConstructorName) {
        AstNode grandParent = parent.parent;
        if (grandParent is ConstructorDeclaration) {
          if (identical(grandParent.redirectedConstructor, parent)) {
            if (grandParent.constKeyword != null) {
              return RedirectingConstructorKind.CONST;
            }
            return RedirectingConstructorKind.NORMAL;
          }
        }
      }
      return null;
    }
  
    /**
     * Return the type represented by the given type name.
     *
     * @param typeName the type name representing the type to be returned
     * @return the type represented by the type name
     */
    DartType _getType(TypeName typeName) {
      DartType type = typeName.type;
      if (type == null) {
        return _undefinedType;
      }
      return type;
    }
  
    /**
     * Returns the simple identifier of the given (may be qualified) type name.
     *
     * @param typeName the (may be qualified) qualified type name
     * @return the simple identifier of the given (may be qualified) type name.
     */
    SimpleIdentifier _getTypeSimpleIdentifier(Identifier typeName) {
      if (typeName is SimpleIdentifier) {
        return typeName;
      } else {
        return (typeName as PrefixedIdentifier).identifier;
      }
    }
  
    /**
     * Given the multiple elements to which a single name could potentially be resolved, return the
     * 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 _getTypeWhenMultiplyDefined(List<Element> elements) {
      InterfaceType type = null;
      for (Element element in elements) {
        if (element is ClassElement) {
          if (type != null) {
            return null;
          }
          type = element.type;
        }
      }
      return type;
    }
  
    /**
     * In strong mode we infer "void" as the setter return type (as void is the
     * only legal return type for a setter). This allows us to give better
     * errors later if an invalid type is returned.
  
negative.code:         }
          typeName.staticType = voidType;
          node.type = voidType;
          return;
        }
        //
        // If not, the look to see whether we might have created the wrong AST
  