Clean up package imports and library names

pkg/analyzer/lib/src/generated/resolver.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.
 
-library engine.resolver;
+library analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
-import '../task/strong/info.dart' show InferredType, StaticInfo;
-import 'ast.dart';
-import 'constant.dart';
-import 'element.dart';
-import 'element_resolver.dart';
-import 'engine.dart';
-import 'error.dart';
-import 'error_verifier.dart';
-import 'java_core.dart';
-import 'java_engine.dart';
-import 'scanner.dart';
-import 'scanner.dart' as sc;
-import 'source.dart';
-import 'static_type_analyzer.dart';
-import 'type_system.dart';
-import 'utilities_dart.dart';
+import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/constant.dart';
+import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/src/generated/element_resolver.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/error.dart';
+import 'package:analyzer/src/generated/error_verifier.dart';
+import 'package:analyzer/src/generated/java_core.dart';
+import 'package:analyzer/src/generated/java_engine.dart';
+import 'package:analyzer/src/generated/scanner.dart';
+import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/static_type_analyzer.dart';
+import 'package:analyzer/src/generated/type_system.dart';
+import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:analyzer/src/task/strong/info.dart' show InferredType, StaticInfo;
 
-export 'type_system.dart';
+export 'package:analyzer/src/generated/type_system.dart';
 
 /**
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
  */
 class BestPracticesVerifier extends RecursiveAstVisitor<Object> {
 //  static String _HASHCODE_GETTER_NAME = "hashCode";
 
   static String _NULL_TYPE_NAME = "Null";
 
@@ skipping 44 matching lines @@
   }
 
   @override
   Object visitAssertStatement(AssertStatement node) {
     _checkForPossibleNullCondition(node.condition);
     return super.visitAssertStatement(node);
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
-    sc.TokenType operatorType = node.operator.type;
-    if (operatorType == sc.TokenType.EQ) {
+    TokenType operatorType = node.operator.type;
+    if (operatorType == TokenType.EQ) {
       _checkForUseOfVoidResult(node.rightHandSide);
       _checkForInvalidAssignment(node.leftHandSide, node.rightHandSide);
     } else {
       _checkForDeprecatedMemberUse(node.bestElement, node);
     }
     return super.visitAssignmentExpression(node);
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
@@ skipping 159 matching lines @@
   bool _checkAllTypeChecks(IsExpression node) {
     Expression expression = node.expression;
     TypeName typeName = node.type;
     DartType lhsType = expression.staticType;
     DartType rhsType = typeName.type;
     if (lhsType == null || rhsType == null) {
       return false;
     }
     String rhsNameStr = typeName.name.name;
     // if x is dynamic
-    if (rhsType.isDynamic && rhsNameStr == sc.Keyword.DYNAMIC.syntax) {
+    if (rhsType.isDynamic && rhsNameStr == Keyword.DYNAMIC.syntax) {
       if (node.notOperator == null) {
         // the is case
         _errorReporter.reportErrorForNode(
             HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node);
       } else {
         // the is not case
         _errorReporter.reportErrorForNode(
             HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node);
       }
       return true;
@@ skipping 239 matching lines @@
 
   /**
    * Check for the passed binary expression for the [HintCode.DIVISION_OPTIMIZATION].
    *
    * @param node the binary expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.DIVISION_OPTIMIZATION].
    */
   bool _checkForDivisionOptimizationHint(BinaryExpression node) {
     // Return if the operator is not '/'
-    if (node.operator.type != sc.TokenType.SLASH) {
+    if (node.operator.type != TokenType.SLASH) {
       return false;
     }
     // Return if the '/' operator is not defined in core, or if we don't know
     // its static or propagated type
     MethodElement methodElement = node.bestElement;
     if (methodElement == null) {
       return false;
     }
     LibraryElement libraryElement = methodElement.library;
     if (libraryElement != null && !libraryElement.isDartCore) {
@@ skipping 1121 matching lines @@
    * Create a new instance of the [DeadCodeVerifier].
    *
    * @param errorReporter the error reporter
    */
   DeadCodeVerifier(this._errorReporter, {TypeSystem typeSystem})
       : this._typeSystem =
             (typeSystem != null) ? typeSystem : new TypeSystemImpl();
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
-    sc.Token operator = node.operator;
-    bool isAmpAmp = operator.type == sc.TokenType.AMPERSAND_AMPERSAND;
-    bool isBarBar = operator.type == sc.TokenType.BAR_BAR;
+    Token operator = node.operator;
+    bool isAmpAmp = operator.type == TokenType.AMPERSAND_AMPERSAND;
+    bool isBarBar = operator.type == TokenType.BAR_BAR;
     if (isAmpAmp || isBarBar) {
       Expression lhsCondition = node.leftOperand;
       if (!_isDebugConstant(lhsCondition)) {
         EvaluationResultImpl lhsResult = _getConstantBooleanValue(lhsCondition);
         if (lhsResult != null) {
           if (lhsResult.value.toBoolValue() == true && isBarBar) {
             // report error on else block: true || !e!
             _errorReporter.reportErrorForNode(
                 HintCode.DEAD_CODE, node.rightOperand);
             // only visit the LHS:
@@ skipping 474 matching lines @@
     } else {
       return super.visitFieldFormalParameter(node);
     }
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
       SimpleIdentifier functionName = node.name;
-      sc.Token property = node.propertyKeyword;
+      Token property = node.propertyKeyword;
       if (property == null) {
         if (_enclosingExecutable != null) {
           _enclosingExecutable =
               _findIdentifier(_enclosingExecutable.functions, functionName);
         } else {
           _enclosingExecutable =
               _findIdentifier(_enclosingUnit.functions, functionName);
         }
       } else {
         if (_enclosingExecutable != null) {
           _enclosingExecutable =
               _findIdentifier(_enclosingExecutable.functions, functionName);
         } else {
           PropertyAccessorElement accessor =
               _findIdentifier(_enclosingUnit.accessors, functionName);
-          if ((property as sc.KeywordToken).keyword == sc.Keyword.SET) {
+          if ((property as KeywordToken).keyword == Keyword.SET) {
             accessor = accessor.variable.setter;
             functionName.staticElement = accessor;
           }
           _enclosingExecutable = accessor;
         }
       }
       node.functionExpression.element = _enclosingExecutable;
       return super.visitFunctionDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
@@ skipping 73 matching lines @@
   @override
   Object visitLibraryDirective(LibraryDirective node) {
     node.element = _enclosingUnit.library;
     return super.visitLibraryDirective(node);
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement outerExecutable = _enclosingExecutable;
     try {
-      sc.Token property = node.propertyKeyword;
+      Token property = node.propertyKeyword;
       SimpleIdentifier methodName = node.name;
       String nameOfMethod = methodName.name;
       if (property == null) {
         _enclosingExecutable = _findWithNameAndOffset(
             _enclosingClass.methods, nameOfMethod, methodName.offset);
         methodName.staticElement = _enclosingExecutable;
       } else {
         PropertyAccessorElement accessor =
             _findIdentifier(_enclosingClass.accessors, methodName);
-        if ((property as sc.KeywordToken).keyword == sc.Keyword.SET) {
+        if ((property as KeywordToken).keyword == Keyword.SET) {
           accessor = accessor.variable.setter;
           methodName.staticElement = accessor;
         }
         _enclosingExecutable = accessor;
       }
       return super.visitMethodDeclaration(node);
     } finally {
       _enclosingExecutable = outerExecutable;
     }
   }
@@ skipping 609 matching lines @@
     if (expression != null) {
       ElementHolder holder = new ElementHolder();
       bool wasInFunction = _inFunction;
       _inFunction = true;
       try {
         _visitChildren(holder, node);
       } finally {
         _inFunction = wasInFunction;
       }
       FunctionBody body = expression.body;
-      sc.Token property = node.propertyKeyword;
+      Token property = node.propertyKeyword;
       if (property == null || _inFunction) {
         SimpleIdentifier functionName = node.name;
         FunctionElementImpl element =
             new FunctionElementImpl.forNode(functionName);
         _setDocRange(element, node);
         if (node.externalKeyword != null) {
           element.external = true;
         }
         element.functions = holder.functions;
         element.labels = holder.labels;
@@ skipping 208 matching lines @@
     try {
       ElementHolder holder = new ElementHolder();
       bool wasInFunction = _inFunction;
       _inFunction = true;
       try {
         _visitChildren(holder, node);
       } finally {
         _inFunction = wasInFunction;
       }
       bool isStatic = node.isStatic;
-      sc.Token property = node.propertyKeyword;
+      Token property = node.propertyKeyword;
       FunctionBody body = node.body;
       if (property == null) {
         SimpleIdentifier methodName = node.name;
         String nameOfMethod = methodName.name;
-        if (nameOfMethod == sc.TokenType.MINUS.lexeme &&
+        if (nameOfMethod == TokenType.MINUS.lexeme &&
             node.parameters.parameters.length == 0) {
           nameOfMethod = "unary-";
         }
         MethodElementImpl element =
             new MethodElementImpl(nameOfMethod, methodName.offset);
         _setDocRange(element, node);
         element.abstract = node.isAbstract;
         if (node.externalKeyword != null) {
           element.external = true;
         }
@@ skipping 980 matching lines @@
 
   @override
   bool visitAssertStatement(AssertStatement node) => false;
 
   @override
   bool visitAssignmentExpression(AssignmentExpression node) {
     Expression leftHandSide = node.leftHandSide;
     if (_nodeExits(leftHandSide)) {
       return true;
     }
-    if (node.operator.type == sc.TokenType.QUESTION_QUESTION_EQ) {
+    if (node.operator.type == TokenType.QUESTION_QUESTION_EQ) {
       return false;
     }
     if (leftHandSide is PropertyAccess &&
-        leftHandSide.operator.type == sc.TokenType.QUESTION_PERIOD) {
+        leftHandSide.operator.type == TokenType.QUESTION_PERIOD) {
       return false;
     }
     return _nodeExits(node.rightHandSide);
   }
 
   @override
   bool visitAwaitExpression(AwaitExpression node) =>
       _nodeExits(node.expression);
 
   @override
   bool visitBinaryExpression(BinaryExpression node) {
     Expression lhsExpression = node.leftOperand;
     Expression rhsExpression = node.rightOperand;
-    sc.TokenType operatorType = node.operator.type;
+    TokenType operatorType = node.operator.type;
     // If the operator is ||, then only consider the RHS of the binary
     // expression if the left hand side is the false literal.
     // TODO(jwren) Do we want to take constant expressions into account,
     // evaluate if(false) {} differently than if(<condition>), when <condition>
     // evaluates to a constant false value?
-    if (operatorType == sc.TokenType.BAR_BAR) {
+    if (operatorType == TokenType.BAR_BAR) {
       if (lhsExpression is BooleanLiteral) {
         BooleanLiteral booleanLiteral = lhsExpression;
         if (!booleanLiteral.value) {
           return _nodeExits(rhsExpression);
         }
       }
       return _nodeExits(lhsExpression);
     }
     // If the operator is &&, then only consider the RHS of the binary
     // expression if the left hand side is the true literal.
-    if (operatorType == sc.TokenType.AMPERSAND_AMPERSAND) {
+    if (operatorType == TokenType.AMPERSAND_AMPERSAND) {
       if (lhsExpression is BooleanLiteral) {
         BooleanLiteral booleanLiteral = lhsExpression;
         if (booleanLiteral.value) {
           return _nodeExits(rhsExpression);
         }
       }
       return _nodeExits(lhsExpression);
     }
     // If the operator is ??, then don't consider the RHS of the binary
     // expression.
-    if (operatorType == sc.TokenType.QUESTION_QUESTION) {
+    if (operatorType == TokenType.QUESTION_QUESTION) {
       return _nodeExits(lhsExpression);
     }
     return _nodeExits(lhsExpression) || _nodeExits(rhsExpression);
   }
 
   @override
   bool visitBlock(Block node) => _visitStatements(node.statements);
 
   @override
   bool visitBlockFunctionBody(BlockFunctionBody node) => _nodeExits(node.block);
@@ skipping 180 matching lines @@
   @override
   bool visitLiteral(Literal node) => false;
 
   @override
   bool visitMethodInvocation(MethodInvocation node) {
     Expression target = node.realTarget;
     if (target != null) {
       if (target.accept(this)) {
         return true;
       }
-      if (node.operator.type == sc.TokenType.QUESTION_PERIOD) {
+      if (node.operator.type == TokenType.QUESTION_PERIOD) {
         return false;
       }
     }
     return _nodeExits(node.argumentList);
   }
 
   @override
   bool visitNamedExpression(NamedExpression node) =>
       node.expression.accept(this);
 
@@ skipping 2070 matching lines @@
    * @return the created synthetic element
    */
   static ExecutableElement _createSyntheticExecutableElement(
       List<ExecutableElement> elementArrayToMerge,
       String name,
       int numOfRequiredParameters,
       int numOfPositionalParameters,
       List<String> namedParameters) {
     DynamicTypeImpl dynamicType = DynamicTypeImpl.instance;
     SimpleIdentifier nameIdentifier = new SimpleIdentifier(
-        new sc.StringToken(sc.TokenType.IDENTIFIER, name, 0));
+        new StringToken(TokenType.IDENTIFIER, name, 0));
     ExecutableElementImpl executable;
     if (elementArrayToMerge[0] is MethodElement) {
       MultiplyInheritedMethodElementImpl unionedMethod =
           new MultiplyInheritedMethodElementImpl(nameIdentifier);
       unionedMethod.inheritedElements = elementArrayToMerge;
       executable = unionedMethod;
     } else {
       MultiplyInheritedPropertyAccessorElementImpl unionedPropertyAccessor =
           new MultiplyInheritedPropertyAccessorElementImpl(nameIdentifier);
       unionedPropertyAccessor.getter =
@@ skipping 1800 matching lines @@
   @override
   Object visitAssertStatement(AssertStatement node) {
     super.visitAssertStatement(node);
     _propagateTrueState(node.condition);
     return null;
   }
 
   @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     safelyVisit(node.leftHandSide);
-    sc.TokenType operator = node.operator.type;
-    if (operator == sc.TokenType.EQ ||
-        operator == sc.TokenType.QUESTION_QUESTION_EQ) {
+    TokenType operator = node.operator.type;
+    if (operator == TokenType.EQ ||
+        operator == TokenType.QUESTION_QUESTION_EQ) {
       InferenceContext.setType(
           node.rightHandSide, node.leftHandSide.staticType);
     }
     safelyVisit(node.rightHandSide);
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitAwaitExpression(AwaitExpression node) {
     //TODO(leafp): Handle the implicit union type here
     DartType contextType = InferenceContext.getType(node);
     if (contextType != null) {
       InterfaceType futureT =
           typeProvider.futureType.substitute4([contextType]);
       InferenceContext.setType(node.expression, futureT);
     }
     return super.visitAwaitExpression(node);
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
-    sc.TokenType operatorType = node.operator.type;
+    TokenType operatorType = node.operator.type;
     Expression leftOperand = node.leftOperand;
     Expression rightOperand = node.rightOperand;
-    if (operatorType == sc.TokenType.AMPERSAND_AMPERSAND) {
+    if (operatorType == TokenType.AMPERSAND_AMPERSAND) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         _overrideManager.enterScope();
         try {
           _promoteManager.enterScope();
           try {
             _propagateTrueState(leftOperand);
             // Type promotion.
             _promoteTypes(leftOperand);
             _clearTypePromotionsIfPotentiallyMutatedIn(leftOperand);
             _clearTypePromotionsIfPotentiallyMutatedIn(rightOperand);
             _clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(
                 rightOperand);
             // Visit right operand.
             rightOperand.accept(this);
           } finally {
             _promoteManager.exitScope();
           }
         } finally {
           _overrideManager.exitScope();
         }
       }
-    } else if (operatorType == sc.TokenType.BAR_BAR) {
+    } else if (operatorType == TokenType.BAR_BAR) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         _overrideManager.enterScope();
         try {
           _propagateFalseState(leftOperand);
           rightOperand.accept(this);
         } finally {
           _overrideManager.exitScope();
         }
       }
@@ skipping 1222 matching lines @@
       _promoteManager.setType(element, potentialType);
     }
   }
 
   /**
    * Promotes type information using given condition.
    */
   void _promoteTypes(Expression condition) {
     if (condition is BinaryExpression) {
       BinaryExpression binary = condition;
-      if (binary.operator.type == sc.TokenType.AMPERSAND_AMPERSAND) {
+      if (binary.operator.type == TokenType.AMPERSAND_AMPERSAND) {
         Expression left = binary.leftOperand;
         Expression right = binary.rightOperand;
         _promoteTypes(left);
         _promoteTypes(right);
         _clearTypePromotionsIfPotentiallyMutatedIn(right);
       }
     } else if (condition is IsExpression) {
       IsExpression is2 = condition;
       if (is2.notOperator == null) {
         _promote(is2.expression, is2.type.type);
       }
     } else if (condition is ParenthesizedExpression) {
       _promoteTypes(condition.expression);
     }
   }
 
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * been evaluated to 'false'.
    *
    * @param condition the condition that will have evaluated to 'false'
    */
   void _propagateFalseState(Expression condition) {
     if (condition is BinaryExpression) {
       BinaryExpression binary = condition;
-      if (binary.operator.type == sc.TokenType.BAR_BAR) {
+      if (binary.operator.type == TokenType.BAR_BAR) {
         _propagateFalseState(binary.leftOperand);
         _propagateFalseState(binary.rightOperand);
       }
     } else if (condition is IsExpression) {
       IsExpression is2 = condition;
       if (is2.notOperator != null) {
         // Since an is-statement doesn't actually change the type, we don't
         // let it affect the propagated type when it would result in a loss
         // of precision.
         overrideExpression(is2.expression, is2.type.type, false, false);
       }
     } else if (condition is PrefixExpression) {
       PrefixExpression prefix = condition;
-      if (prefix.operator.type == sc.TokenType.BANG) {
+      if (prefix.operator.type == TokenType.BANG) {
         _propagateTrueState(prefix.operand);
       }
     } else if (condition is ParenthesizedExpression) {
       _propagateFalseState(condition.expression);
     }
   }
 
   /**
    * Propagate any type information that results from knowing that the given expression will have
    * been evaluated without altering the flow of execution.
    *
    * @param expression the expression that will have been evaluated
    */
   void _propagateState(Expression expression) {
     // TODO(brianwilkerson) Implement this.
   }
 
   /**
    * Propagate any type information that results from knowing that the given condition will have
    * been evaluated to 'true'.
    *
    * @param condition the condition that will have evaluated to 'true'
    */
   void _propagateTrueState(Expression condition) {
     if (condition is BinaryExpression) {
       BinaryExpression binary = condition;
-      if (binary.operator.type == sc.TokenType.AMPERSAND_AMPERSAND) {
+      if (binary.operator.type == TokenType.AMPERSAND_AMPERSAND) {
         _propagateTrueState(binary.leftOperand);
         _propagateTrueState(binary.rightOperand);
       }
     } else if (condition is IsExpression) {
       IsExpression is2 = condition;
       if (is2.notOperator == null) {
         // Since an is-statement doesn't actually change the type, we don't
         // let it affect the propagated type when it would result in a loss
         // of precision.
         overrideExpression(is2.expression, is2.type.type, false, false);
       }
     } else if (condition is PrefixExpression) {
       PrefixExpression prefix = condition;
-      if (prefix.operator.type == sc.TokenType.BANG) {
+      if (prefix.operator.type == TokenType.BANG) {
         _propagateFalseState(prefix.operand);
       }
     } else if (condition is ParenthesizedExpression) {
       _propagateTrueState(condition.expression);
     }
   }
 }
 
 /**
  * The abstract class `Scope` defines the behavior common to name scopes used by the resolver
@@ skipping 315 matching lines @@
         new AnalysisError(source, offset, length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
-  void reportErrorForToken(ErrorCode errorCode, sc.Token token,
+  void reportErrorForToken(ErrorCode errorCode, Token token,
       [List<Object> arguments]) {
     errorListener.onError(new AnalysisError(
         source, token.offset, token.length, errorCode, arguments));
   }
 
   /**
    * Visit the given AST node if it is not null.
    *
    * @param node the node to be visited
    */
@@ skipping 722 matching lines @@
   void findIn(CompilationUnit unit) {
     _gatherTodoComments(unit.beginToken);
   }
 
   /**
    * Search the comment tokens reachable from the given token and create errors for each to-do
    * comment.
    *
    * @param token the head of the list of tokens being searched
    */
-  void _gatherTodoComments(sc.Token token) {
-    while (token != null && token.type != sc.TokenType.EOF) {
-      sc.Token commentToken = token.precedingComments;
+  void _gatherTodoComments(Token token) {
+    while (token != null && token.type != TokenType.EOF) {
+      Token commentToken = token.precedingComments;
       while (commentToken != null) {
-        if (commentToken.type == sc.TokenType.SINGLE_LINE_COMMENT ||
-            commentToken.type == sc.TokenType.MULTI_LINE_COMMENT) {
+        if (commentToken.type == TokenType.SINGLE_LINE_COMMENT ||
+            commentToken.type == TokenType.MULTI_LINE_COMMENT) {
           _scrapeTodoComment(commentToken);
         }
         commentToken = commentToken.next;
       }
       token = token.next;
     }
   }
 
   /**
    * Look for user defined tasks in comments and convert them into info level analysis issues.
    *
    * @param commentToken the comment token to analyze
    */
-  void _scrapeTodoComment(sc.Token commentToken) {
+  void _scrapeTodoComment(Token commentToken) {
     JavaPatternMatcher matcher =
         new JavaPatternMatcher(TodoCode.TODO_REGEX, commentToken.lexeme);
     if (matcher.find()) {
       int offset =
           commentToken.offset + matcher.start() + matcher.group(1).length;
       int length = matcher.group(2).length;
       _errorReporter.reportErrorForOffset(
           TodoCode.TODO, offset, length, [matcher.group(2)]);
     }
   }
@@ skipping 1854 matching lines @@
       ClassElement element = type.element;
       if (element != null && element.isEnum) {
         reportErrorForNode(enumTypeError, typeName);
         return null;
       }
       return type;
     }
     // If the type is not an InterfaceType, then visitTypeName() sets the type
     // to be a DynamicTypeImpl
     Identifier name = typeName.name;
-    if (name.name == sc.Keyword.DYNAMIC.syntax) {
+    if (name.name == Keyword.DYNAMIC.syntax) {
       reportErrorForNode(dynamicTypeError, name, [name.name]);
     } else {
       reportErrorForNode(nonTypeError, name, [name.name]);
     }
     return null;
   }
 
   /**
    * Resolve the types in the given list of type names.
    *
@@ skipping 52 matching lines @@
     functionElement.shareParameters(parameters);
     functionElement.returnType = _computeReturnType(returnType);
     functionElement.enclosingElement = element;
     element.type = new FunctionTypeImpl(functionElement);
   }
 
   /**
    * @return `true` if the name of the given [TypeName] is an built-in identifier.
    */
   static bool _isBuiltInIdentifier(TypeName node) {
-    sc.Token token = node.name.beginToken;
-    return token.type == sc.TokenType.KEYWORD;
+    Token token = node.name.beginToken;
+    return token.type == TokenType.KEYWORD;
   }
 
   /**
    * @return `true` if given [TypeName] is used as a type annotation.
    */
   static bool _isTypeAnnotation(TypeName node) {
     AstNode parent = node.parent;
     if (parent is VariableDeclarationList) {
       return identical(parent.type, node);
     }
@@ skipping 567 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }