Use limited JavaStringBuilder implementation instead of Dart StringBuffer.

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 'source.dart';
 import 'error.dart';
@@ skipping 851 matching lines @@
     return null;
   }
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier methodName2 = node.methodName;
     Expression target = node.realTarget;
     Element element;
     if (target == null) {
       element = _resolver.nameScope.lookup(methodName2, _resolver.definingLibrary);
       if (element == null) {
         element = lookUpMethod(_resolver.enclosingClass, methodName2.name);
+        if (element == null) {
+          PropertyAccessorElement getter = lookUpGetter(_resolver.enclosingClass, methodName2.name);
+          if (getter != null) {
+            FunctionType getterType = getter.type;
+            if (getterType != null) {
+              Type2 returnType4 = getterType.returnType;
+              if (!returnType4.isDynamic() && returnType4 is! FunctionType && !returnType4.isDartCoreFunction()) {
+                _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
+              }
+            }
+            recordResolution(methodName2, getter);
+            return null;
+          }
+        }
       }
     } else {
       Type2 targetType = getType(target);
       if (targetType is InterfaceType) {
         element = lookUpMethod(targetType.element, methodName2.name);
         if (element == null) {
           PropertyAccessorElement accessor = lookUpGetterInType((targetType.element as ClassElement), methodName2.name);
           if (accessor != null) {
-            Type2 returnType4 = accessor.type.returnType;
-            if (!returnType4.isDynamic() && returnType4 is! FunctionType) {
+            Type2 returnType5 = accessor.type.returnType;
+            if (!returnType5.isDynamic() && returnType5 is! FunctionType && !returnType5.isDartCoreFunction()) {
               _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
               return null;
             }
             element = accessor;
           }
         }
         if (element == null && target is SuperExpression) {
           _resolver.reportError(StaticTypeWarningCode.UNDEFINED_SUPER_METHOD, methodName2, [methodName2.name, targetType.element.name]);
           return null;
         }
@@ skipping 11 matching lines @@
       }
     }
     ExecutableElement invokedMethod = null;
     if (element is ExecutableElement) {
       invokedMethod = element as ExecutableElement;
     } else {
       if (element is PropertyInducingElement) {
         PropertyAccessorElement getter3 = ((element as PropertyInducingElement)).getter;
         FunctionType getterType = getter3.type;
         if (getterType != null) {
-          Type2 returnType5 = getterType.returnType;
-          if (!returnType5.isDynamic() && returnType5 is! FunctionType) {
+          Type2 returnType6 = getterType.returnType;
+          if (!returnType6.isDynamic() && returnType6 is! FunctionType && !returnType6.isDartCoreFunction()) {
             _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
           }
         }
         recordResolution(methodName2, element);
         return null;
       } else if (element is VariableElement) {
         Type2 variableType = ((element as VariableElement)).type;
-        if (!variableType.isDynamic() && variableType is! FunctionType) {
+        if (!variableType.isDynamic() && variableType is! FunctionType && !variableType.isDartCoreFunction()) {
           _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
         }
         recordResolution(methodName2, element);
         return null;
       } else {
         _resolver.reportError(StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION, methodName2, [methodName2.name]);
         return null;
       }
     }
     recordResolution(methodName2, invokedMethod);
@@ skipping 849 matching lines @@
     this._libraryElement = libraryElement2;
   }
   String toString() => _librarySource.shortName;
   /**
    * Append the value of the given string literal to the given string builder.
    * @param builder the builder to which the string's value is to be appended
    * @param literal the string literal whose value is to be appended to the builder
    * @throws IllegalArgumentException if the string is not a constant string without any string
    * interpolation
    */
-  void appendStringValue(StringBuffer builder, StringLiteral literal) {
+  void appendStringValue(JavaStringBuilder builder, StringLiteral literal) {
     if (literal is SimpleStringLiteral) {
-      builder.write(((literal as SimpleStringLiteral)).value);
+      builder.append(((literal as SimpleStringLiteral)).value);
     } else if (literal is AdjacentStrings) {
       for (StringLiteral stringLiteral in ((literal as AdjacentStrings)).strings) {
         appendStringValue(builder, stringLiteral);
       }
     } else {
       throw new IllegalArgumentException();
     }
   }
   /**
    * Return the result of resolving the given URI against the URI of the library, or {@code 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 _librarySource.resolve(uri);
   }
   /**
    * Return the value of the given string literal, or {@code 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) {
-    StringBuffer builder = new StringBuffer();
+    JavaStringBuilder builder = new JavaStringBuilder();
     try {
       appendStringValue(builder, literal);
     } on IllegalArgumentException catch (exception) {
       return null;
     }
     return builder.toString().trim();
   }
 }
 /**
  * Instances of the class {@code LibraryElementBuilder} build an element model for a single library.
@@ skipping 1613 matching lines @@
    */
   Object visitThrowExpression(ThrowExpression node) => recordType(node, _typeProvider.bottomType);
   /**
    * 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
    * the expression.
    * @param node the function expression whose return type is to be computed
    * @return the return type that was computed
    */
   Type2 computeReturnType(FunctionDeclaration node) {
-    TypeName returnType6 = node.returnType;
-    if (returnType6 == null) {
+    TypeName returnType7 = node.returnType;
+    if (returnType7 == null) {
       return computeReturnType2(node.functionExpression);
     }
-    return returnType6.type;
+    return returnType7.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
    * the expression.
    * @param node the function expression whose return type is to be computed
    * @return the return type that was computed
    */
   Type2 computeReturnType2(FunctionExpression node) {
     FunctionBody body4 = node.body;
@@ skipping 106 matching lines @@
     }
     return null;
   }
   /**
    * 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 returnType9, FormalParameterList parameterList) {
+  void setTypeInformation(FunctionTypeImpl functionType, Type2 returnType10, 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 = returnType9;
+    functionType.returnType = returnType10;
   }
 }
 /**
  * The interface {@code TypeProvider} defines the behavior of objects that provide access to types
  * defined by the language.
  */
 abstract class TypeProvider {
   /**
    * Return the type representing the built-in type 'bool'.
    * @return the type representing the built-in type 'bool'
@@ skipping 667 matching lines @@
       }
     }
   }
   /**
    * 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 returnType10, List<ParameterElement> parameters) {
+  void setTypeInformation(FunctionTypeImpl functionType, TypeName returnType11, 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 (returnType10 == null) {
+    if (returnType11 == null) {
       functionType.returnType = _dynamicType;
     } else {
-      functionType.returnType = returnType10.type;
+      functionType.returnType = returnType11.type;
     }
   }
 }
 /**
  * Instances of the class {@code ClassScope} implement the scope defined by a class.
  */
 class ClassScope extends EnclosedScope {
   /**
    * Initialize a newly created scope enclosed within another scope.
    * @param enclosingScope the scope in which this scope is lexically enclosed
@@ skipping 825 matching lines @@
   Object visitAssignmentExpression(AssignmentExpression node) {
     Expression lhs = node.leftHandSide;
     Expression rhs = node.rightHandSide;
     Type2 leftType = getType(lhs);
     Type2 rightType = getType(rhs);
     if (!rightType.isAssignableTo(leftType)) {
       _errorReporter.reportError(StaticTypeWarningCode.INVALID_ASSIGNMENT, rhs, [leftType.name, rightType.name]);
     }
     return super.visitAssignmentExpression(node);
   }
+  Object visitClassDeclaration(ClassDeclaration node) {
+    checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME);
+    return super.visitClassDeclaration(node);
+  }
+  Object visitClassTypeAlias(ClassTypeAlias node) {
+    checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
+    return super.visitClassTypeAlias(node);
+  }
   Object visitConditionalExpression(ConditionalExpression node) {
     checkForNonBoolCondition(node.condition);
     return super.visitConditionalExpression(node);
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ExecutableElement previousFunction = _currentFunction;
     try {
       _currentFunction = node.element;
       return super.visitConstructorDeclaration(node);
     } finally {
@@ skipping 15 matching lines @@
   }
   Object visitFunctionExpression(FunctionExpression node) {
     ExecutableElement previousFunction = _currentFunction;
     try {
       _currentFunction = node.element;
       return super.visitFunctionExpression(node);
     } finally {
       _currentFunction = previousFunction;
     }
   }
+  Object visitFunctionTypeAlias(FunctionTypeAlias node) {
+    checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME);
+    return super.visitFunctionTypeAlias(node);
+  }
   Object visitIfStatement(IfStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitIfStatement(node);
   }
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     ConstructorName constructorName4 = node.constructorName;
     TypeName typeName = constructorName4.type;
     Type2 createdType = typeName.type;
     if (createdType is InterfaceType) {
       if (((createdType as InterfaceType)).element.isAbstract()) {
@@ skipping 43 matching lines @@
     Type2 expectedReturnType = functionType == null ? null : functionType.returnType;
     Expression returnExpression = node.expression;
     if (expectedReturnType != null && !expectedReturnType.isVoid() && returnExpression != null) {
       Type2 actualReturnType = getType(returnExpression);
       if (!actualReturnType.isAssignableTo(expectedReturnType)) {
         _errorReporter.reportError(StaticTypeWarningCode.RETURN_OF_INVALID_TYPE, returnExpression, [actualReturnType.name, expectedReturnType.name]);
       }
     }
     return super.visitReturnStatement(node);
   }
+  Object visitTypeParameter(TypeParameter node) {
+    checkForBuiltInIdentifierAsName(node.name, CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_VARIABLE_NAME);
+    return super.visitTypeParameter(node);
+  }
   Object visitWhileStatement(WhileStatement node) {
     checkForNonBoolCondition(node.condition);
     return super.visitWhileStatement(node);
   }
   /**
+   * 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}
+   */
+  void checkForBuiltInIdentifierAsName(SimpleIdentifier identifier, ErrorCode errorCode) {
+    Token token13 = identifier.token;
+    if (identical(token13.type, TokenType.KEYWORD)) {
+      _errorReporter.reportError(errorCode, identifier, [identifier.name]);
+    }
+  }
+  /**
    * Checks to ensure that the expressions that need to be of type bool, are. Otherwise an error is
    * reported on the expression.
    * @see StaticTypeWarningCode#NON_BOOL_CONDITION
    * @param condition the conditional expression to test
    */
   void checkForNonBoolCondition(Expression condition) {
     Type2 conditionType = getType(condition);
     if (conditionType != null && !conditionType.isAssignableTo(_typeProvider.boolType)) {
       _errorReporter.reportError(StaticTypeWarningCode.NON_BOOL_CONDITION, condition, []);
     }
@@ skipping 39 matching lines @@
   ResolverErrorCode(this.__name, this.__ordinal, ErrorType type, String message) {
     this._type = type;
     this._message = message;
   }
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
   bool needsRecompilation() => true;
   String toString() => __name;
 }