Add '--useAnalysisHighlight2' option to generate version 2 of semantic highlight.

pkg/analysis_server/lib/src/computer/computer_highlights2.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 computer.highlights;
+library computer.highlights2;
 
 import 'package:analysis_server/src/protocol.dart' hide Element;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 
 /**
  * A computer for [HighlightRegion]s in a Dart [CompilationUnit].
  */
-class DartUnitHighlightsComputer {
+class DartUnitHighlightsComputer2 {
   final CompilationUnit _unit;
 
   final List<HighlightRegion> _regions = <HighlightRegion>[];
 
-  DartUnitHighlightsComputer(this._unit);
+  DartUnitHighlightsComputer2(this._unit);
 
   /**
    * Returns the computed highlight regions, not `null`.
    */
   List<HighlightRegion> compute() {
-    _unit.accept(new _DartUnitHighlightsComputerVisitor(this));
+    _unit.accept(new _DartUnitHighlightsComputerVisitor2(this));
     _addCommentRanges();
     return _regions;
   }
 
   void _addCommentRanges() {
     Token token = _unit.beginToken;
     while (token != null && token.type != TokenType.EOF) {
       Token commentToken = token.precedingComments;
       while (commentToken != null) {
         HighlightRegionType highlightType = null;
@@ skipping 19 matching lines @@
   void _addIdentifierRegion(SimpleIdentifier node) {
     if (_addIdentifierRegion_keyword(node)) {
       return;
     }
     if (_addIdentifierRegion_class(node)) {
       return;
     }
     if (_addIdentifierRegion_constructor(node)) {
       return;
     }
-    if (_addIdentifierRegion_dynamicType(node)) {
+    if (_addIdentifierRegion_dynamicLocal(node)) {
       return;
     }
     if (_addIdentifierRegion_getterSetterDeclaration(node)) {
       return;
     }
     if (_addIdentifierRegion_field(node)) {
       return;
     }
     if (_addIdentifierRegion_function(node)) {
       return;
@@ skipping 51 matching lines @@
   }
 
   bool _addIdentifierRegion_constructor(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is! ConstructorElement) {
       return false;
     }
     return _addRegion_node(node, HighlightRegionType.CONSTRUCTOR);
   }
 
-  bool _addIdentifierRegion_dynamicType(SimpleIdentifier node) {
-    // should be variable
-    Element element = node.staticElement;
-    if (element is! VariableElement) {
-      return false;
-    }
-    // has propagated type
+  bool _addIdentifierRegion_dynamicLocal(SimpleIdentifier node) {
+    // no propagated type
     if (node.propagatedType != null) {
       return false;
     }
     // has dynamic static type
     DartType staticType = node.staticType;
     if (staticType == null || !staticType.isDynamic) {
       return false;
     }
     // OK
-    return _addRegion_node(node, HighlightRegionType.DYNAMIC_TYPE);
+    Element element = node.staticElement;
+    if (element is LocalVariableElement) {
+      HighlightRegionType type = node.inDeclarationContext()
+          ? HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_DECLARATION
+          : HighlightRegionType.DYNAMIC_LOCAL_VARIABLE_REFERENCE;
+      return _addRegion_node(node, type);
+    }
+    if (element is ParameterElement) {
+      HighlightRegionType type = node.inDeclarationContext()
+          ? HighlightRegionType.DYNAMIC_PARAMETER_DECLARATION
+          : HighlightRegionType.DYNAMIC_PARAMETER_REFERENCE;
+      return _addRegion_node(node, type);
+    }
+    return false;
   }
 
   bool _addIdentifierRegion_field(SimpleIdentifier node) {
     Element element = node.bestElement;
     if (element is FieldFormalParameterElement) {
       element = (element as FieldFormalParameterElement).field;
     }
-    if (element is PropertyAccessorElement) {
-      element = (element as PropertyAccessorElement).variable;
-    }
     // prepare type
     HighlightRegionType type;
     if (element is FieldElement) {
       Element enclosingElement = element.enclosingElement;
       if (enclosingElement is ClassElement && enclosingElement.isEnum) {
         type = HighlightRegionType.ENUM_CONSTANT;
       } else if (element.isStatic) {
-        type = HighlightRegionType.FIELD_STATIC;
+        type = HighlightRegionType.STATIC_FIELD_DECLARATION;
       } else {
-        type = HighlightRegionType.FIELD;
+        type = node.inDeclarationContext()
+            ? HighlightRegionType.INSTANCE_FIELD_DECLARATION
+            : HighlightRegionType.INSTANCE_FIELD_REFERENCE;
       }
     } else if (element is TopLevelVariableElement) {
-      type = HighlightRegionType.TOP_LEVEL_VARIABLE;
+      type = HighlightRegionType.TOP_LEVEL_VARIABLE_DECLARATION;
+    }
+    if (element is PropertyAccessorElement) {
+      PropertyAccessorElement accessor = element;
+      Element enclosingElement = element.enclosingElement;
+      if (accessor.variable is TopLevelVariableElement) {
+        type = accessor.isGetter
+            ? HighlightRegionType.TOP_LEVEL_GETTER_REFERENCE
+            : HighlightRegionType.TOP_LEVEL_SETTER_REFERENCE;
+      } else if (enclosingElement is ClassElement && enclosingElement.isEnum) {
+        type = HighlightRegionType.ENUM_CONSTANT;
+      } else if (accessor.isStatic) {
+        type = accessor.isGetter
+            ? HighlightRegionType.STATIC_GETTER_REFERENCE
+            : HighlightRegionType.STATIC_SETTER_REFERENCE;
+      } else {
+        type = accessor.isGetter
+            ? HighlightRegionType.INSTANCE_GETTER_REFERENCE
+            : HighlightRegionType.INSTANCE_SETTER_REFERENCE;
+      }
     }
     // add region
     if (type != null) {
       return _addRegion_node(node, type);
     }
     return false;
   }
 
   bool _addIdentifierRegion_function(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is! FunctionElement) {
       return false;
     }
     HighlightRegionType type;
+    bool isTopLevel = element.enclosingElement is CompilationUnitElement;
     if (node.inDeclarationContext()) {
-      type = HighlightRegionType.FUNCTION_DECLARATION;
+      type = isTopLevel
+          ? HighlightRegionType.TOP_LEVEL_FUNCTION_DECLARATION
+          : HighlightRegionType.LOCAL_FUNCTION_DECLARATION;
     } else {
-      type = HighlightRegionType.FUNCTION;
+      type = isTopLevel
+          ? HighlightRegionType.TOP_LEVEL_FUNCTION_REFERENCE
+          : HighlightRegionType.LOCAL_FUNCTION_REFERENCE;
     }
     return _addRegion_node(node, type);
   }
 
   bool _addIdentifierRegion_functionTypeAlias(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is! FunctionTypeAliasElement) {
       return false;
     }
     return _addRegion_node(node, HighlightRegionType.FUNCTION_TYPE_ALIAS);
   }
 
   bool _addIdentifierRegion_getterSetterDeclaration(SimpleIdentifier node) {
     // should be declaration
     AstNode parent = node.parent;
     if (!(parent is MethodDeclaration || parent is FunctionDeclaration)) {
       return false;
     }
     // should be property accessor
     Element element = node.staticElement;
     if (element is! PropertyAccessorElement) {
       return false;
     }
     // getter or setter
     PropertyAccessorElement propertyAccessorElement =
         element as PropertyAccessorElement;
+    bool isTopLevel = element.enclosingElement is CompilationUnitElement;
+    HighlightRegionType type;
     if (propertyAccessorElement.isGetter) {
-      return _addRegion_node(node, HighlightRegionType.GETTER_DECLARATION);
+      if (isTopLevel) {
+        type = HighlightRegionType.TOP_LEVEL_GETTER_DECLARATION;
+      } else if (propertyAccessorElement.isStatic) {
+        type = HighlightRegionType.STATIC_GETTER_DECLARATION;
+      } else {
+        type = HighlightRegionType.INSTANCE_GETTER_DECLARATION;
+      }
     } else {
-      return _addRegion_node(node, HighlightRegionType.SETTER_DECLARATION);
+      if (isTopLevel) {
+        type = HighlightRegionType.TOP_LEVEL_SETTER_DECLARATION;
+      } else if (propertyAccessorElement.isStatic) {
+        type = HighlightRegionType.STATIC_SETTER_DECLARATION;
+      } else {
+        type = HighlightRegionType.INSTANCE_SETTER_DECLARATION;
+      }
     }
+    return _addRegion_node(node, type);
   }
 
   bool _addIdentifierRegion_importPrefix(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is! PrefixElement) {
       return false;
     }
     return _addRegion_node(node, HighlightRegionType.IMPORT_PREFIX);
   }
 
@@ skipping 12 matching lines @@
     }
     return _addRegion_node(node, HighlightRegionType.LABEL);
   }
 
   bool _addIdentifierRegion_localVariable(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is! LocalVariableElement) {
       return false;
     }
     // OK
-    HighlightRegionType type;
-    if (node.inDeclarationContext()) {
-      type = HighlightRegionType.LOCAL_VARIABLE_DECLARATION;
-    } else {
-      type = HighlightRegionType.LOCAL_VARIABLE;
-    }
+    HighlightRegionType type = node.inDeclarationContext()
+        ? HighlightRegionType.LOCAL_VARIABLE_DECLARATION
+        : HighlightRegionType.LOCAL_VARIABLE_REFERENCE;
     return _addRegion_node(node, type);
   }
 
   bool _addIdentifierRegion_method(SimpleIdentifier node) {
     Element element = node.bestElement;
     if (element is! MethodElement) {
       return false;
     }
     MethodElement methodElement = element as MethodElement;
     bool isStatic = methodElement.isStatic;
     // OK
     HighlightRegionType type;
     if (node.inDeclarationContext()) {
       if (isStatic) {
-        type = HighlightRegionType.METHOD_DECLARATION_STATIC;
+        type = HighlightRegionType.STATIC_METHOD_DECLARATION;
       } else {
-        type = HighlightRegionType.METHOD_DECLARATION;
+        type = HighlightRegionType.INSTANCE_METHOD_DECLARATION;
       }
     } else {
       if (isStatic) {
-        type = HighlightRegionType.METHOD_STATIC;
+        type = HighlightRegionType.STATIC_METHOD_REFERENCE;
       } else {
-        type = HighlightRegionType.METHOD;
+        type = HighlightRegionType.INSTANCE_METHOD_REFERENCE;
       }
     }
     return _addRegion_node(node, type);
   }
 
   bool _addIdentifierRegion_parameter(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is! ParameterElement) {
       return false;
     }
-    return _addRegion_node(node, HighlightRegionType.PARAMETER);
+    HighlightRegionType type = node.inDeclarationContext()
+        ? HighlightRegionType.PARAMETER_DECLARATION
+        : HighlightRegionType.PARAMETER_REFERENCE;
+    return _addRegion_node(node, type);
   }
 
   bool _addIdentifierRegion_typeParameter(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is! TypeParameterElement) {
       return false;
     }
     return _addRegion_node(node, HighlightRegionType.TYPE_PARAMETER);
   }
 
@@ skipping 25 matching lines @@
 
   void _addRegion_tokenStart_tokenEnd(
       Token a, Token b, HighlightRegionType type) {
     int offset = a.offset;
     int end = b.end;
     _addRegion(offset, end - offset, type);
   }
 }
 
 /**
- * An AST visitor for [DartUnitHighlightsComputer].
+ * An AST visitor for [DartUnitHighlightsComputer2].
  */
-class _DartUnitHighlightsComputerVisitor extends RecursiveAstVisitor<Object> {
-  final DartUnitHighlightsComputer computer;
+class _DartUnitHighlightsComputerVisitor2 extends RecursiveAstVisitor<Object> {
+  final DartUnitHighlightsComputer2 computer;
 
-  _DartUnitHighlightsComputerVisitor(this.computer);
+  _DartUnitHighlightsComputerVisitor2(this.computer);
 
   @override
   Object visitAnnotation(Annotation node) {
     computer._addIdentifierRegion_annotation(node);
     return super.visitAnnotation(node);
   }
 
   @override
   Object visitAsExpression(AsExpression node) {
     computer._addRegion_token(node.asOperator, HighlightRegionType.BUILT_IN);
@@ skipping 355 matching lines @@
   void _addRegions_functionBody(FunctionBody node) {
     Token keyword = node.keyword;
     if (keyword != null) {
       Token star = node.star;
       int offset = keyword.offset;
       int end = star != null ? star.end : keyword.end;
       computer._addRegion(offset, end - offset, HighlightRegionType.BUILT_IN);
     }
   }
 }