Computers and services snapshot.

pkg/analysis_server/lib/src/generated/service_computers.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 service.computers;
 
 import 'package:analyzer/src/generated/java_core.dart' show JavaStringBuilder, StringUtils;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:analyzer/src/generated/scanner.dart' show Token;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart' as pae;
 import 'package:analyzer/src/generated/element.dart' show DartType;
 import 'package:analyzer/src/generated/source.dart';
 import 'service_interfaces.dart' as psi;
 
 /**
+ * A concrete implementation of [CompletionSuggestion].
+ */
+class CompletionSuggestionImpl implements psi.CompletionSuggestion {
+  final String completion;
+
+  final String declaringType;
+
+  final String elementDocSummary;
+
+  final String elementDocDetails;
+
+  final psi.CompletionSuggestionKind kind;
+
+  final int location;
+
+  final String parameterName;
+
+  final List<String> parameterNames;
+
+  final String parameterType;
+
+  final List<String> parameterTypes;
+
+  final int positionalParameterCount;
+
+  final int relevance;
+
+  final int replacementLength;
+
+  final int replacementLengthIdentifier;
+
+  final String returnType;
+
+  final bool hasNamed;
+
+  final bool hasPositional;
+
+  final bool isDeprecated;
+
+  final bool isPotentialMatch;
+
+  CompletionSuggestionImpl(this.elementDocSummary, this.elementDocDetails, this.completion, this.declaringType, this.kind, this.location, this.parameterName, this.parameterNames, this.parameterType, this.parameterTypes, this.positionalParameterCount, this.relevance, this.replacementLength, this.replacementLengthIdentifier, this.returnType, this.hasNamed, this.hasPositional, this.isDeprecated, this.isPotentialMatch);
+}
+
+/**
  * A computer for [HighlightRegion]s in a Dart [CompilationUnit].
  */
 class DartUnitHighlightsComputer {
   final CompilationUnit _unit;
 
   List<psi.HighlightRegion> _regions = [];
 
   DartUnitHighlightsComputer(this._unit);
 
   /**
@@ skipping 268 matching lines @@
     int offset = a.offset;
     int end = b.end;
     _addRegion(offset, end - offset, type);
   }
 }
 
 /**
  * A computer for [NavigationRegion]s in a Dart [CompilationUnit].
  */
 class DartUnitNavigationComputer {
+  final String _contextId;
+
   final CompilationUnit _unit;
 
   List<psi.NavigationRegion> _regions = [];
 
-  DartUnitNavigationComputer(this._unit);
+  DartUnitNavigationComputer(this._contextId, this._unit);
 
   /**
    * Returns the computed [NavigationRegion]s, not `null`.
    */
   List<psi.NavigationRegion> compute() {
     _unit.accept(new RecursiveAstVisitor_DartUnitNavigationComputer_compute(this));
     return new List.from(_regions);
   }
 
   /**
    * If the given [Element] is not `null`, then creates a corresponding
    * [NavigationRegion].
    */
   void _addRegion(int offset, int length, pae.Element element) {
     psi.Element target = _createTarget(element);
     if (target == null) {
       return;
     }
     _regions.add(new NavigationRegionImpl(offset, length, <psi.Element> [target]));
   }
 
+  void _addRegion_nodeStart_nodeEnd(AstNode a, AstNode b, pae.Element element) {
+    int offset = a.offset;
+    int length = b.end - offset;
+    _addRegion(offset, length, element);
+  }
+
+  void _addRegion_nodeStart_nodeStart(AstNode a, AstNode b, pae.Element element) {
+    int offset = a.offset;
+    int length = b.offset - offset;
+    _addRegion(offset, length, element);
+  }
+
   void _addRegion_tokenStart_nodeEnd(Token a, AstNode b, pae.Element element) {
     int offset = a.offset;
     int length = b.end - offset;
     _addRegion(offset, length, element);
   }
 
   /**
    * If the given [Element] is not `null`, then creates a corresponding
    * [NavigationRegion].
    */
@@ skipping 17 matching lines @@
    * Returns the [com.google.dart.server.Element] for the given [Element], maybe
    * `null` if `null` was given.
    */
   psi.Element _createTarget(pae.Element element) {
     if (element == null) {
       return null;
     }
     if (element is pae.FieldFormalParameterElement) {
       element = (element as pae.FieldFormalParameterElement).field;
     }
-    return ElementImpl.create(element);
+    return ElementImpl.create(_contextId, element);
   }
 }
 
 /**
  * A computer for [Outline]s in a Dart [CompilationUnit].
  */
 class DartUnitOutlineComputer {
   static String _UNITTEST_LIBRARY = "unittest";
 
+  final String _contextId;
+
   final Source _source;
 
   final CompilationUnit _unit;
 
-  DartUnitOutlineComputer(this._source, this._unit);
+  DartUnitOutlineComputer(this._contextId, this._source, this._unit);
 
   /**
    * Returns the computed [Outline]s, not `null`.
    */
   psi.Outline compute() {
     OutlineImpl unitOutline = _newUnitOutline();
     List<psi.Outline> unitChildren = [];
     for (CompilationUnitMember unitMember in _unit.declarations) {
       if (unitMember is ClassDeclaration) {
         ClassDeclaration classDeclartion = unitMember;
         OutlineImpl classOutline = _newClassOutline(unitOutline, unitChildren, classDeclartion);
         List<psi.Outline> classChildren = [];
         for (ClassMember classMember in classDeclartion.members) {
           if (classMember is ConstructorDeclaration) {
             ConstructorDeclaration constructorDeclaration = classMember;
             _newConstructorOutline(classOutline, classChildren, constructorDeclaration);
           }
           if (classMember is FieldDeclaration) {
             FieldDeclaration fieldDeclaration = classMember;
             VariableDeclarationList fields = fieldDeclaration.fields;
             if (fields != null) {
               TypeName fieldType = fields.type;
               String fieldTypeName = fieldType != null ? fieldType.toSource() : "";
               for (VariableDeclaration field in fields.variables) {
-                _newField(classOutline, classChildren, fieldTypeName, field, fieldDeclaration.isStatic);
+                _newVariableOutline(classOutline, classChildren, fieldTypeName, psi.ElementKind.FIELD, field, fieldDeclaration.isStatic);
               }
             }
           }
           if (classMember is MethodDeclaration) {
             MethodDeclaration methodDeclaration = classMember;
             _newMethodOutline(classOutline, classChildren, methodDeclaration);
           }
         }
         classOutline.children = new List.from(classChildren);
       }
+      if (unitMember is TopLevelVariableDeclaration) {
+        TopLevelVariableDeclaration fieldDeclaration = unitMember;
+        VariableDeclarationList fields = fieldDeclaration.variables;
+        if (fields != null) {
+          TypeName fieldType = fields.type;
+          String fieldTypeName = fieldType != null ? fieldType.toSource() : "";
+          for (VariableDeclaration field in fields.variables) {
+            _newVariableOutline(unitOutline, unitChildren, fieldTypeName, psi.ElementKind.TOP_LEVEL_VARIABLE, field, false);
+          }
+        }
+      }
       if (unitMember is FunctionDeclaration) {
         FunctionDeclaration functionDeclaration = unitMember;
         _newFunctionOutline(unitOutline, unitChildren, functionDeclaration);
       }
       if (unitMember is ClassTypeAlias) {
         ClassTypeAlias alias = unitMember;
         _newClassTypeAlias(unitOutline, unitChildren, alias);
       }
       if (unitMember is FunctionTypeAlias) {
         FunctionTypeAlias alias = unitMember;
@@ skipping 36 matching lines @@
             nameLength = name.length;
           } else {
             name = "??????????";
             nameOffset = nameNode.offset;
             nameLength = nameNode.length;
           }
         }
         // add a new outline
         FunctionExpression functionExpression = arguments[1] as FunctionExpression;
         SourceRegionImpl sourceRegion = new SourceRegionImpl(node.offset, node.length);
-        ElementImpl element = new ElementImpl(null, _source, unitTestKind, name, nameOffset, nameLength, null, null, false, false, false);
+        ElementImpl element = new ElementImpl(_contextId, null, _source, unitTestKind, name, nameOffset, nameLength, null, null, false, false, false);
         OutlineImpl outline = new OutlineImpl(parent, element, sourceRegion);
         children.add(outline);
         _addLocalFunctionOutlines(outline, functionExpression.body);
         return true;
       }
     }
     return false;
   }
 
   /**
@@ skipping 58 matching lines @@
           return libraryElement != null && _UNITTEST_LIBRARY == libraryElement.name;
         }
       }
     }
     return false;
   }
 
   OutlineImpl _newClassOutline(psi.Outline unitOutline, List<psi.Outline> unitChildren, ClassDeclaration classDeclaration) {
     SimpleIdentifier nameNode = classDeclaration.name;
     String name = nameNode.name;
-    ElementImpl element = new ElementImpl(ElementImpl.createId(classDeclaration.element), _source, psi.ElementKind.CLASS, name, nameNode.offset, name.length, null, null, classDeclaration.isAbstract, false, StringUtilities.startsWithChar(name, 0x5F));
+    ElementImpl element = new ElementImpl(_contextId, ElementImpl.createId(classDeclaration.element), _source, psi.ElementKind.CLASS, name, nameNode.offset, name.length, null, null, classDeclaration.isAbstract, false, StringUtilities.startsWithChar(name, 0x5F));
     psi.SourceRegion sourceRegion = _getSourceRegion(classDeclaration);
     OutlineImpl outline = new OutlineImpl(unitOutline, element, sourceRegion);
     unitChildren.add(outline);
     return outline;
   }
 
   void _newClassTypeAlias(psi.Outline unitOutline, List<psi.Outline> unitChildren, ClassTypeAlias alias) {
     SimpleIdentifier nameNode = alias.name;
     String name = nameNode.name;
-    ElementImpl element = new ElementImpl(ElementImpl.createId(alias.element), _source, psi.ElementKind.CLASS_TYPE_ALIAS, name, nameNode.offset, nameNode.length, null, null, alias.isAbstract, false, StringUtilities.startsWithChar(name, 0x5F));
+    ElementImpl element = new ElementImpl(_contextId, ElementImpl.createId(alias.element), _source, psi.ElementKind.CLASS_TYPE_ALIAS, name, nameNode.offset, nameNode.length, null, null, alias.isAbstract, false, StringUtilities.startsWithChar(name, 0x5F));
     psi.SourceRegion sourceRegion = _getSourceRegion(alias);
     OutlineImpl outline = new OutlineImpl(unitOutline, element, sourceRegion);
     unitChildren.add(outline);
   }
 
   void _newConstructorOutline(OutlineImpl classOutline, List<psi.Outline> children, ConstructorDeclaration constructorDeclaration) {
     Identifier returnType = constructorDeclaration.returnType;
     String name = returnType.name;
     int offset = returnType.offset;
     int length = returnType.length;
     bool isPrivate = false;
     SimpleIdentifier constructorNameNode = constructorDeclaration.name;
     if (constructorNameNode != null) {
       String constructorName = constructorNameNode.name;
       isPrivate = StringUtilities.startsWithChar(constructorName, 0x5F);
       name += ".${constructorName}";
       offset = constructorNameNode.offset;
       length = constructorNameNode.length;
     }
     FormalParameterList parameters = constructorDeclaration.parameters;
-    ElementImpl element = new ElementImpl(ElementImpl.createId(constructorDeclaration.element), _source, psi.ElementKind.CONSTRUCTOR, name, offset, length, parameters != null ? parameters.toSource() : "", null, false, false, isPrivate);
+    ElementImpl element = new ElementImpl(_contextId, ElementImpl.createId(constructorDeclaration.element), _source, psi.ElementKind.CONSTRUCTOR, name, offset, length, parameters != null ? parameters.toSource() : "", null, false, false, isPrivate);
     psi.SourceRegion sourceRegion = _getSourceRegion(constructorDeclaration);
     OutlineImpl outline = new OutlineImpl(classOutline, element, sourceRegion);
     children.add(outline);
     _addLocalFunctionOutlines(outline, constructorDeclaration.body);
   }
 
-  void _newField(OutlineImpl classOutline, List<psi.Outline> children, String fieldTypeName, VariableDeclaration field, bool isStatic) {
-    SimpleIdentifier nameNode = field.name;
-    String name = nameNode.name;
-    ElementImpl element = new ElementImpl(ElementImpl.createId(field.element), _source, psi.ElementKind.FIELD, name, nameNode.offset, nameNode.length, null, fieldTypeName, false, isStatic, StringUtilities.startsWithChar(name, 0x5F));
-    psi.SourceRegion sourceRegion = _getSourceRegion(field);
-    OutlineImpl outline = new OutlineImpl(classOutline, element, sourceRegion);
-    children.add(outline);
-  }
-
   void _newFunctionOutline(psi.Outline parent, List<psi.Outline> children, FunctionDeclaration functionDeclaration) {
     TypeName returnType = functionDeclaration.returnType;
     SimpleIdentifier nameNode = functionDeclaration.name;
     String name = nameNode.name;
     FunctionExpression functionExpression = functionDeclaration.functionExpression;
     FormalParameterList parameters = functionExpression.parameters;
     psi.ElementKind kind;
     if (functionDeclaration.isGetter) {
       kind = psi.ElementKind.GETTER;
     } else if (functionDeclaration.isSetter) {
       kind = psi.ElementKind.SETTER;
     } else {
       kind = psi.ElementKind.FUNCTION;
     }
-    ElementImpl element = new ElementImpl(ElementImpl.createId(functionDeclaration.element), _source, kind, name, nameNode.offset, nameNode.length, parameters != null ? parameters.toSource() : "", returnType != null ? returnType.toSource() : "", false, false, StringUtilities.startsWithChar(name, 0x5F));
+    ElementImpl element = new ElementImpl(_contextId, ElementImpl.createId(functionDeclaration.element), _source, kind, name, nameNode.offset, nameNode.length, parameters != null ? parameters.toSource() : "", returnType != null ? returnType.toSource() : "", false, false, StringUtilities.startsWithChar(name, 0x5F));
     psi.SourceRegion sourceRegion = _getSourceRegion(functionDeclaration);
     OutlineImpl outline = new OutlineImpl(parent, element, sourceRegion);
     children.add(outline);
     _addLocalFunctionOutlines(outline, functionExpression.body);
   }
 
   void _newFunctionTypeAliasOutline(psi.Outline unitOutline, List<psi.Outline> unitChildren, FunctionTypeAlias alias) {
     TypeName returnType = alias.returnType;
     SimpleIdentifier nameNode = alias.name;
     String name = nameNode.name;
     FormalParameterList parameters = alias.parameters;
-    ElementImpl element = new ElementImpl(ElementImpl.createId(alias.element), _source, psi.ElementKind.FUNCTION_TYPE_ALIAS, name, nameNode.offset, nameNode.length, parameters != null ? parameters.toSource() : "", returnType != null ? returnType.toSource() : "", false, false, StringUtilities.startsWithChar(name, 0x5F));
+    ElementImpl element = new ElementImpl(_contextId, ElementImpl.createId(alias.element), _source, psi.ElementKind.FUNCTION_TYPE_ALIAS, name, nameNode.offset, nameNode.length, parameters != null ? parameters.toSource() : "", returnType != null ? returnType.toSource() : "", false, false, StringUtilities.startsWithChar(name, 0x5F));
     psi.SourceRegion sourceRegion = _getSourceRegion(alias);
     OutlineImpl outline = new OutlineImpl(unitOutline, element, sourceRegion);
     unitChildren.add(outline);
   }
 
   void _newMethodOutline(OutlineImpl classOutline, List<psi.Outline> children, MethodDeclaration methodDeclaration) {
     TypeName returnType = methodDeclaration.returnType;
     SimpleIdentifier nameNode = methodDeclaration.name;
     String name = nameNode.name;
     FormalParameterList parameters = methodDeclaration.parameters;
     psi.ElementKind kind;
     if (methodDeclaration.isGetter) {
       kind = psi.ElementKind.GETTER;
     } else if (methodDeclaration.isSetter) {
       kind = psi.ElementKind.SETTER;
     } else {
       kind = psi.ElementKind.METHOD;
     }
-    ElementImpl element = new ElementImpl(ElementImpl.createId(methodDeclaration.element), _source, kind, name, nameNode.offset, nameNode.length, parameters != null ? parameters.toSource() : "", returnType != null ? returnType.toSource() : "", methodDeclaration.isAbstract, methodDeclaration.isStatic, StringUtilities.startsWithChar(name, 0x5F));
+    ElementImpl element = new ElementImpl(_contextId, ElementImpl.createId(methodDeclaration.element), _source, kind, name, nameNode.offset, nameNode.length, parameters != null ? parameters.toSource() : "", returnType != null ? returnType.toSource() : "", methodDeclaration.isAbstract, methodDeclaration.isStatic, StringUtilities.startsWithChar(name, 0x5F));
     psi.SourceRegion sourceRegion = _getSourceRegion(methodDeclaration);
     OutlineImpl outline = new OutlineImpl(classOutline, element, sourceRegion);
     children.add(outline);
     _addLocalFunctionOutlines(outline, methodDeclaration.body);
   }
 
   OutlineImpl _newUnitOutline() {
-    ElementImpl element = new ElementImpl(ElementImpl.createId(_unit.element), _source, psi.ElementKind.COMPILATION_UNIT, null, 0, 0, null, null, false, false, false);
+    ElementImpl element = new ElementImpl(_contextId, ElementImpl.createId(_unit.element), _source, psi.ElementKind.COMPILATION_UNIT, null, 0, 0, null, null, false, false, false);
     return new OutlineImpl(null, element, new SourceRegionImpl(_unit.offset, _unit.length));
   }
+
+  void _newVariableOutline(OutlineImpl classOutline, List<psi.Outline> children, String typeName, psi.ElementKind kind, VariableDeclaration variable, bool isStatic) {
+    SimpleIdentifier nameNode = variable.name;
+    String name = nameNode.name;
+    ElementImpl element = new ElementImpl(_contextId, ElementImpl.createId(variable.element), _source, kind, name, nameNode.offset, nameNode.length, null, typeName, false, isStatic, StringUtilities.startsWithChar(name, 0x5F));
+    psi.SourceRegion sourceRegion = _getSourceRegion(variable);
+    OutlineImpl outline = new OutlineImpl(classOutline, element, sourceRegion);
+    children.add(outline);
+  }
 }
 
 /**
  * A concrete implementation of [Element].
  */
 class ElementImpl implements psi.Element {
   /**
    * Creates an [ElementImpl] instance for the given
    * [com.google.dart.engine.element.Element].
    */
-  static ElementImpl create(pae.Element element) {
+  static ElementImpl create(String contextId, pae.Element element) {
+    if (element == null) {
+      return null;
+    }
     // prepare name
     String name = element.displayName;
     int nameOffset = element.nameOffset;
     int nameLength = name != null ? name.length : 0;
     // prepare element kind specific information
     psi.ElementKind outlineKind;
     bool isAbstract = false;
     bool isStatic = false;
     bool isPrivate = element.isPrivate;
     while (true) {
       if (element.kind == pae.ElementKind.CLASS) {
         outlineKind = psi.ElementKind.CLASS;
         isAbstract = (element as pae.ClassElement).isAbstract;
       } else if (element.kind == pae.ElementKind.COMPILATION_UNIT) {
         outlineKind = psi.ElementKind.COMPILATION_UNIT;
         nameOffset = -1;
         nameLength = 0;
       } else if (element.kind == pae.ElementKind.CONSTRUCTOR) {
         outlineKind = psi.ElementKind.CONSTRUCTOR;
         String className = element.enclosingElement.name;
         if (name.length != 0) {
           name = "${className}.${name}";
         } else {
           name = className;
         }
       } else if (element.kind == pae.ElementKind.FUNCTION) {
         outlineKind = psi.ElementKind.FUNCTION;
+      } else if (element.kind == pae.ElementKind.GETTER) {
+        outlineKind = psi.ElementKind.GETTER;
       } else if (element.kind == pae.ElementKind.FUNCTION_TYPE_ALIAS) {
         outlineKind = psi.ElementKind.FUNCTION_TYPE_ALIAS;
       } else if (element.kind == pae.ElementKind.LIBRARY) {
         outlineKind = psi.ElementKind.LIBRARY;
       } else if (element.kind == pae.ElementKind.METHOD) {
         outlineKind = psi.ElementKind.METHOD;
         isAbstract = (element as pae.MethodElement).isAbstract;
+      } else if (element.kind == pae.ElementKind.SETTER) {
+        outlineKind = psi.ElementKind.SETTER;
       } else {
         outlineKind = psi.ElementKind.UNKNOWN;
       }
       break;
     }
     // extract return type and parameters from toString()
     // TODO(scheglov) we need a way to get this information directly from an Element
     String parameters;
     String returnType;
     {
       String str = element.toString();
       // return type
       String rightArrow = pae.Element.RIGHT_ARROW;
       int returnIndex = str.lastIndexOf(rightArrow);
       if (returnIndex != -1) {
         returnType = str.substring(returnIndex + rightArrow.length);
         str = str.substring(0, returnIndex);
       } else {
         returnType = null;
       }
       // parameters
       int parametersIndex = str.indexOf("(");
       if (parametersIndex != -1) {
         parameters = str.substring(parametersIndex);
       } else {
         parameters = null;
       }
     }
     // new element
-    return new ElementImpl(createId(element), element.source, outlineKind, name, nameOffset, nameLength, parameters, returnType, isAbstract, isStatic, isPrivate);
+    return new ElementImpl(contextId, createId(element), element.source, outlineKind, name, nameOffset, nameLength, parameters, returnType, isAbstract, isStatic, isPrivate);
   }
 
   /**
    * Returns an identifier of the given [Element], maybe `null` if `null` given.
    */
   static String createId(pae.Element element) {
     if (element == null) {
       return null;
     }
     return element.location.encoding;
   }
 
+  final String contextId;
+
   final String id;
 
   final Source source;
 
   final psi.ElementKind kind;
 
   final String name;
 
   final int offset;
 
   final int length;
 
   final String parameters;
 
   final String returnType;
 
   final bool isAbstract;
 
   final bool isPrivate;
 
   final bool isStatic;
 
-  ElementImpl(this.id, this.source, this.kind, this.name, this.offset, this.length, this.parameters, this.returnType, this.isAbstract, this.isStatic, this.isPrivate);
+  ElementImpl(this.contextId, this.id, this.source, this.kind, this.name, this.offset, this.length, this.parameters, this.returnType, this.isAbstract, this.isStatic, this.isPrivate);
 
   @override
   bool operator ==(Object obj) {
     if (identical(obj, this)) {
       return true;
     }
     if (obj is! ElementImpl) {
       return false;
     }
     ElementImpl other = obj as ElementImpl;
@@ skipping 21 matching lines @@
     builder.append(length);
     builder.append(", parameters=");
     builder.append(parameters);
     builder.append(", return=");
     builder.append(returnType);
     builder.append("]");
     return builder.toString();
   }
 }
 
+class GeneralizingElementVisitor_TypeHierarchyComputer_findEngineElement extends pae.GeneralizingElementVisitor<Object> {
+  int nameOffset = 0;
+
+  List<pae.Element> result;
+
+  GeneralizingElementVisitor_TypeHierarchyComputer_findEngineElement(this.nameOffset, this.result) : super();
+
+  @override
+  Object visitElement(pae.Element element) {
+    if (element.nameOffset == nameOffset) {
+      result[0] = element;
+    }
+    return super.visitElement(element);
+  }
+}
+
 /**
  * A concrete implementation of [HighlightRegion].
  */
 class HighlightRegionImpl extends SourceRegionImpl implements psi.HighlightRegion {
   final psi.HighlightType type;
 
   HighlightRegionImpl(int offset, int length, this.type) : super(offset, length);
 
   @override
   String toString() {
@@ skipping 254 matching lines @@
     return super.visitAssignmentExpression(node);
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     DartUnitNavigationComputer_this._addRegionForToken(node.operator, node.bestElement);
     return super.visitBinaryExpression(node);
   }
 
   @override
+  Object visitConstructorDeclaration(ConstructorDeclaration node) {
+    // associate constructor with "T" or "T.name"
+    {
+      AstNode firstNode = node.returnType;
+      AstNode lastNode = node.name;
+      if (lastNode == null) {
+        lastNode = firstNode;
+      }
+      if (firstNode != null && lastNode != null) {
+        DartUnitNavigationComputer_this._addRegion_nodeStart_nodeEnd(firstNode, lastNode, node.element);
+      }
+    }
+    return super.visitConstructorDeclaration(node);
+  }
+
+  @override
   Object visitExportDirective(ExportDirective node) {
     pae.ExportElement exportElement = node.element;
     if (exportElement != null) {
       pae.Element element = exportElement.exportedLibrary;
       DartUnitNavigationComputer_this._addRegion_tokenStart_nodeEnd(node.keyword, node.uri, element);
     }
     return super.visitExportDirective(node);
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
     pae.ImportElement importElement = node.element;
     if (importElement != null) {
       pae.Element element = importElement.importedLibrary;
       DartUnitNavigationComputer_this._addRegion_tokenStart_nodeEnd(node.keyword, node.uri, element);
     }
     return super.visitImportDirective(node);
   }
 
   @override
   Object visitIndexExpression(IndexExpression node) {
     DartUnitNavigationComputer_this._addRegionForToken(node.rightBracket, node.bestElement);
     return super.visitIndexExpression(node);
   }
 
   @override
+  Object visitInstanceCreationExpression(InstanceCreationExpression node) {
+    DartUnitNavigationComputer_this._addRegion_nodeStart_nodeStart(node, node.argumentList, node.staticElement);
+    return super.visitInstanceCreationExpression(node);
+  }
+
+  @override
   Object visitPartDirective(PartDirective node) {
     DartUnitNavigationComputer_this._addRegion_tokenStart_nodeEnd(node.keyword, node.uri, node.element);
     return super.visitPartDirective(node);
   }
 
   @override
   Object visitPartOfDirective(PartOfDirective node) {
     DartUnitNavigationComputer_this._addRegion_tokenStart_nodeEnd(node.keyword, node.libraryName, node.element);
     return super.visitPartOfDirective(node);
   }
 
   @override
   Object visitPostfixExpression(PostfixExpression node) {
     DartUnitNavigationComputer_this._addRegionForToken(node.operator, node.bestElement);
     return super.visitPostfixExpression(node);
   }
 
   @override
   Object visitPrefixExpression(PrefixExpression node) {
     DartUnitNavigationComputer_this._addRegionForToken(node.operator, node.bestElement);
     return super.visitPrefixExpression(node);
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
-    DartUnitNavigationComputer_this._addRegionForNode(node, node.bestElement);
+    if (node.parent is ConstructorDeclaration) {
+    } else {
+      DartUnitNavigationComputer_this._addRegionForNode(node, node.bestElement);
+    }
     return super.visitSimpleIdentifier(node);
   }
 }
 
 class RecursiveAstVisitor_DartUnitOutlineComputer_addLocalFunctionOutlines extends RecursiveAstVisitor<Object> {
   final DartUnitOutlineComputer DartUnitOutlineComputer_this;
 
   OutlineImpl parent;
 
   List<psi.Outline> localOutlines;
@@ skipping 23 matching lines @@
   final List<psi.Element> path;
 
   final Source source;
 
   final psi.SearchResultKind kind;
 
   final int offset;
 
   final int length;
 
-  SearchResultImpl(this.path, this.source, this.kind, this.offset, this.length);
+  final bool isPotential;
+
+  SearchResultImpl(this.path, this.source, this.kind, this.offset, this.length, this.isPotential);
 
   @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("[source=");
     builder.append(source);
     builder.append(", kind=");
     builder.append(kind);
     builder.append(", offset=");
     builder.append(offset);
     builder.append(", length=");
     builder.append(length);
+    builder.append(", potential=");
+    builder.append(isPotential);
     builder.append(", path=");
     builder.append(path);
     builder.append("]");
     return builder.toString();
   }
 }
 
 /**
  * A concrete implementation of [SourceRegion].
  */
@@ skipping 25 matching lines @@
   @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("[offset=");
     builder.append(offset);
     builder.append(", length=");
     builder.append(length);
     builder.append("]");
     return builder.toString();
   }
+}
+
+/**
+ * A concrete implementation of [TypeHierarchyItem].
+ */
+class TypeHierarchyItemImpl implements psi.TypeHierarchyItem {
+  final String name;
+
+  final psi.Element classElement;
+
+  final psi.Element memberElement;
+
+  final psi.TypeHierarchyItem extendedType;
+
+  final List<psi.TypeHierarchyItem> mixedTypes;
+
+  final List<psi.TypeHierarchyItem> implementedTypes;
+
+  List<psi.TypeHierarchyItem> subTypes = psi.TypeHierarchyItem.EMPTY_ARRAY;
+
+  TypeHierarchyItemImpl(this.name, this.classElement, this.memberElement, this.extendedType, this.mixedTypes, this.implementedTypes);
+
+  @override
+  String toString() {
+    JavaStringBuilder builder = new JavaStringBuilder();
+    builder.append("[name=");
+    builder.append(name);
+    builder.append(", classElement=");
+    builder.append(classElement);
+    builder.append(", memberElement=");
+    builder.append(memberElement);
+    builder.append(", extendedType=");
+    builder.append(extendedType);
+    builder.append(", mixedTypes=[");
+    builder.append(StringUtils.join(mixedTypes, ", "));
+    builder.append("], implementedTypes=[");
+    builder.append(StringUtils.join(implementedTypes, ", "));
+    builder.append("], subTypes=[");
+    builder.append(StringUtils.join(subTypes, ", "));
+    builder.append("]]");
+    return builder.toString();
+  }
 }