Remove Math and most uses of PrintStringWriter

pkg/analysis_server/lib/src/services/generated/util.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // 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 services.util;
 
 import 'dart:collection';
+import "dart:math" as math;
+
 import 'package:analyzer/src/generated/java_core.dart' hide StringUtils;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/scanner.dart';
+
 import 'stubs.dart';
 
 /**
  * Context for which assistance should be provided.
  */
 class AssistContext {
   final SearchEngine searchEngine;
 
   final AnalysisContext analysisContext;
 
@@ skipping 340 matching lines @@
       return null;
     }
     // prepare parents
     List<List<AstNode>> parents = [];
     for (AstNode node in nodes) {
       parents.add(getParents(node));
     }
     // find min length
     int minLength = 2147483647;
     for (List<AstNode> parentList in parents) {
-      minLength = Math.min(minLength, parentList.length);
+      minLength = math.min(minLength, parentList.length);
     }
     // find deepest parent
     int i = 0;
     for (; i < minLength; i++) {
       if (!allListsEqual(parents, i)) {
         break;
       }
     }
     return parents[0][i - 1];
   }
@@ skipping 119 matching lines @@
     }
     return null;
   }
 
   /**
    * Returns the name of the file which corresponds to the name of the class according to the style
    * guide. However class does not have to be in this file.
    */
   static String getRecommentedFileNameForClass(String className) {
     int len = className.length;
-    JavaStringBuilder sb = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     bool prevWasUpper = false;
     for (int i = 0; i < len; i++) {
       int c = className.codeUnitAt(i);
       if (Character.isUpperCase(c)) {
         bool nextIsUpper = i < len - 1 && Character.isUpperCase(className.codeUnitAt(i + 1));
         if (i == 0) {
         } else if (prevWasUpper) {
           // HTTPServer
           //     ^
           if (!nextIsUpper) {
-            sb.appendChar(0x5F);
+            buffer.writeCharCode(0x5F);
           }
         } else {
           // HttpServer
           //     ^
-          sb.appendChar(0x5F);
+          buffer.writeCharCode(0x5F);
         }
         prevWasUpper = true;
         c = Character.toLowerCase(c);
       } else {
         prevWasUpper = false;
       }
-      sb.appendChar(c);
+      buffer.writeCharCode(c);
     }
-    sb.append(".dart");
-    String fileName = sb.toString();
+    buffer.write(".dart");
+    String fileName = buffer.toString();
     return fileName;
   }
 
   /**
    * @return given [Statement] if not [Block], first child [Statement] if
    *         [Block], or <code>null</code> if more than one child.
    */
   static Statement getSingleStatement(Statement statement) {
     if (statement is Block) {
       List<Statement> blockStatements = statement.statements;
@@ skipping 35 matching lines @@
     }
     return elements;
   }
 
   /**
    * @return the possible names for variable with initializer of the given [StringLiteral].
    */
   static List<String> getVariableNameSuggestions(String text, Set<String> excluded) {
     // filter out everything except of letters and white spaces
     {
-      JavaStringBuilder sb = new JavaStringBuilder();
+      StringBuffer buffer = new StringBuffer();
       for (int i = 0; i < text.length; i++) {
         int c = text.codeUnitAt(i);
         if (Character.isLetter(c) || Character.isWhitespace(c)) {
-          sb.appendChar(c);
+          buffer.writeCharCode(c);
         }
       }
-      text = sb.toString();
+      text = buffer.toString();
     }
     // make single camel-case text
     {
       List<String> words = StringUtils.split(text);
-      JavaStringBuilder sb = new JavaStringBuilder();
+      StringBuffer buffer = new StringBuffer();
       for (int i = 0; i < words.length; i++) {
         String word = words[i];
         if (i > 0) {
           word = StringUtils.capitalize(word);
         }
-        sb.append(word);
+        buffer.write(word);
       }
-      text = sb.toString();
+      text = buffer.toString();
     }
     // split camel-case into separate suggested names
     Set<String> res = new LinkedHashSet();
     _addAll(excluded, res, _getVariableNameSuggestions(text));
     return new List.from(res);
   }
 
   /**
    * @return the possible names for variable with given expected type and expression.
    */
@@ skipping 319 matching lines @@
     String oldSource = getText3(range);
     return getIndentSource3(oldSource, oldIndent, newIndent);
   }
 
   /**
    * Indents given source left or right.
    *
    * @return the source with changed indentation.
    */
   String getIndentSource2(String source, bool right) {
-    JavaStringBuilder sb = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     String indent = getIndent(1);
     String eol = endOfLine;
     List<String> lines = StringUtils.splitByWholeSeparatorPreserveAllTokens(source, eol);
     for (int i = 0; i < lines.length; i++) {
       String line = lines[i];
       // last line, stop if empty
       if (i == lines.length - 1 && StringUtils.isEmpty(line)) {
         break;
       }
       // update line
       if (right) {
         line = "${indent}${line}";
       } else {
         line = StringUtils.removeStart(line, indent);
       }
       // append line
-      sb.append(line);
-      sb.append(eol);
+      buffer.write(line);
+      buffer.write(eol);
     }
-    return sb.toString();
+    return buffer.toString();
   }
 
   /**
    * @return the source with indentation changed from "oldIndent" to "newIndent", keeping
    *         indentation of the lines relative to each other.
    */
   String getIndentSource3(String source, String oldIndent, String newIndent) {
     // prepare STRING token ranges
     List<SourceRange> lineRanges = [];
     for (Token token in TokenUtils.getTokens(source)) {
       if (token.type == TokenType.STRING) {
         lineRanges.add(SourceRangeFactory.rangeToken(token));
       }
     }
     // re-indent lines
-    JavaStringBuilder sb = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     String eol = endOfLine;
     List<String> lines = StringUtils.splitByWholeSeparatorPreserveAllTokens(source, eol);
     int lineOffset = 0;
     for (int i = 0; i < lines.length; i++) {
       String line = lines[i];
       // last line, stop if empty
       if (i == lines.length - 1 && StringUtils.isEmpty(line)) {
         break;
       }
       // check if "offset" is in one of the String ranges
       bool inString = false;
       for (SourceRange lineRange in lineRanges) {
         inString = javaBooleanOr(inString, lineOffset > lineRange.offset && lineOffset < lineRange.end);
         if (lineOffset > lineRange.end) {
           break;
         }
       }
       lineOffset += line.length + eol.length;
       // update line indent
       if (!inString) {
         line = "${newIndent}${StringUtils.removeStart(line, oldIndent)}";
       }
       // append line
-      sb.append(line);
-      sb.append(eol);
+      buffer.write(line);
+      buffer.write(eol);
     }
-    return sb.toString();
+    return buffer.toString();
   }
 
   /**
    * @return [InsertDesc], description where to insert new library-related directive.
    */
   CorrectionUtils_InsertDesc get insertDescImport {
     // analyze directives
     Directive prevDirective = null;
     for (Directive directive in unit.directives) {
       if (directive is LibraryDirective || directive is ImportDirective || directive is ExportDirective) {
@@ skipping 266 matching lines @@
    * @return the source for the parameter with the given type and name.
    */
   String getParameterSource(DartType type, String name) {
     // no type
     if (type == null || type.isDynamic) {
       return name;
     }
     // function type
     if (type is FunctionType) {
       FunctionType functionType = type;
-      JavaStringBuilder sb = new JavaStringBuilder();
+      StringBuffer buffer = new StringBuffer();
       // return type
       DartType returnType = functionType.returnType;
       if (returnType != null && !returnType.isDynamic) {
-        sb.append(getTypeSource2(returnType));
-        sb.appendChar(0x20);
+        buffer.write(getTypeSource2(returnType));
+        buffer.writeCharCode(0x20);
       }
       // parameter name
-      sb.append(name);
+      buffer.write(name);
       // parameters
-      sb.appendChar(0x28);
+      buffer.writeCharCode(0x28);
       List<ParameterElement> fParameters = functionType.parameters;
       for (int i = 0; i < fParameters.length; i++) {
         ParameterElement fParameter = fParameters[i];
         if (i != 0) {
-          sb.append(", ");
+          buffer.write(", ");
         }
-        sb.append(getParameterSource(fParameter.type, fParameter.name));
+        buffer.write(getParameterSource(fParameter.type, fParameter.name));
       }
-      sb.appendChar(0x29);
+      buffer.writeCharCode(0x29);
       // done
-      return sb.toString();
+      return buffer.toString();
     }
     // simple type
     return "${getTypeSource2(type)} ${name}";
   }
 
   /**
    * @return the line prefix consisting of spaces and tabs on the left from the given offset.
    */
   String getPrefix(int endIndex) {
     int startIndex = getLineContentStart(endIndex);
@@ skipping 33 matching lines @@
     if ("dynamic" == typeSource) {
       return null;
     }
     return typeSource;
   }
 
   /**
    * @return the source to reference the given [Type] in this [CompilationUnit].
    */
   String getTypeSource2(DartType type) {
-    JavaStringBuilder sb = new JavaStringBuilder();
+    StringBuffer buffer = new StringBuffer();
     // prepare element
     Element element = type.element;
     if (element == null) {
       String source = type.toString();
       source = StringUtils.remove(source, "<dynamic>");
       source = StringUtils.remove(source, "<dynamic, dynamic>");
       return source;
     }
     // append prefix
     {
       ImportElement imp = _getImportElement(element);
       if (imp != null && imp.prefix != null) {
-        sb.append(imp.prefix.displayName);
-        sb.append(".");
+        buffer.write(imp.prefix.displayName);
+        buffer.write(".");
       }
     }
     // append simple name
     String name = element.displayName;
-    sb.append(name);
+    buffer.write(name);
     // may be type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       List<DartType> arguments = interfaceType.typeArguments;
       // check if has arguments
       bool hasArguments = false;
       for (DartType argument in arguments) {
         if (!argument.isDynamic) {
           hasArguments = true;
           break;
         }
       }
       // append type arguments
       if (hasArguments) {
-        sb.append("<");
+        buffer.write("<");
         for (int i = 0; i < arguments.length; i++) {
           DartType argument = arguments[i];
           if (i != 0) {
-            sb.append(", ");
+            buffer.write(", ");
           }
-          sb.append(getTypeSource2(argument));
+          buffer.write(getTypeSource2(argument));
         }
-        sb.append(">");
+        buffer.write(">");
       }
     }
     // done
-    return sb.toString();
+    return buffer.toString();
   }
 
   /**
    * @return <code>true</code> if selection range contains only whitespace.
    */
   bool isJustWhitespace(SourceRange range) => getText3(range).trim().length == 0;
 
   /**
    * @return <code>true</code> if selection range contains only whitespace or comments
    */
@@ skipping 309 matching lines @@
       return [];
     }
   }
 
   /**
    * @return <code>true</code> if given [Token]s contain only single [Token] with given
    *         [TokenType].
    */
   static bool hasOnly(List<Token> tokens, TokenType type) => tokens.length == 1 && tokens[0].type == type;
 }