Add lookupInScope to DeclarationMirror.

sdk/lib/_internal/compiler/implementation/mirrors/dart2js_mirror.dart

 // Copyright (c) 2012, 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 mirrors_dart2js;
 
 import 'dart:async';
 import 'dart:collection' show LinkedHashMap;
 
 import '../../compiler.dart' as api;
 import '../elements/elements.dart';
 import '../apiimpl.dart' as apiimpl;
 import '../scanner/scannerlib.dart' hide SourceString;
+import '../resolution/resolution.dart' show Scope;
 import '../dart2jslib.dart';
 import '../dart_types.dart';
 import '../source_file.dart';
 import '../tree/tree.dart';
 import '../util/util.dart' show Spannable, Link;
 import '../util/characters.dart' show $CR, $LF;
 
 import 'mirrors.dart';
 import 'mirrors_util.dart';
 import 'util.dart';
 
 //------------------------------------------------------------------------------
 // Utility types and functions for the dart2js mirror system
 //------------------------------------------------------------------------------
 
 bool _isPrivate(String name) {
   return name.startsWith('_');
 }
 
 List<ParameterMirror> _parametersFromFunctionSignature(
     Dart2JsMirrorSystem system,
     Dart2JsMethodMirror method,
     FunctionSignature signature) {
   var parameters = <ParameterMirror>[];
   Link<Element> link = signature.requiredParameters;
   while (!link.isEmpty) {
     parameters.add(new Dart2JsParameterMirror(
-        system, method, link.head, false, false));
+        system, method, link.head, isOptional: false, isNamed: false));
     link = link.tail;
   }
   link = signature.optionalParameters;
   bool isNamed = signature.optionalParametersAreNamed;
   while (!link.isEmpty) {
     parameters.add(new Dart2JsParameterMirror(
-        system, method, link.head, true, isNamed));
+        system, method, link.head, isOptional: true, isNamed: isNamed));
     link = link.tail;
   }
   return parameters;
 }
 
 Dart2JsTypeMirror _convertTypeToTypeMirror(
     Dart2JsMirrorSystem system,
     DartType type,
     InterfaceType defaultType,
     [FunctionSignature functionSignature]) {
@@ skipping 282 matching lines @@
       span = new SourceSpan(script.uri, 0, 0);
     } else {
       Token endToken = getEndToken();
       span = mirrors.compiler.spanFromTokens(beginToken, endToken, script.uri);
     }
     return new Dart2JsSourceLocation(script, span);
   }
 
   String toString() => _element.toString();
 
-  int get hashCode => qualifiedName.hashCode;
-
   void _appendCommentTokens(Token commentToken) {
     while (commentToken != null && commentToken.kind == COMMENT_TOKEN) {
       _metadata.add(new Dart2JsCommentInstanceMirror(
           mirrors, commentToken.slowToString()));
       commentToken = commentToken.next;
     }
   }
 
   List<InstanceMirror> get metadata {
     if (_metadata == null) {
       _metadata = <InstanceMirror>[];
       for (MetadataAnnotation metadata in _element.metadata) {
         _appendCommentTokens(mirrors.compiler.commentMap[metadata.beginToken]);
         metadata.ensureResolved(mirrors.compiler);
         _metadata.add(
             _convertConstantToInstanceMirror(mirrors, metadata.value));
       }
       _appendCommentTokens(mirrors.compiler.commentMap[getBeginToken()]);
     }
     // TODO(johnniwinther): Return an unmodifiable list instead.
     return new List<InstanceMirror>.from(_metadata);
   }
+
+  DeclarationMirror lookupInScope(String name) {
+    // TODO(11653): Support lookup of constructors.
+    Scope scope = _element.buildScope();
+    Element result;
+    int index = name.indexOf('.');
+    if (index != -1) {
+      // Lookup [: prefix.id :].
+      String prefix = name.substring(0, index);
+      String id = name.substring(index+1);
+      result = scope.lookup(new SourceString(prefix)); 
+      if (result != null && result.isPrefix()) {
+        PrefixElement prefix = result;
+        result = prefix.lookupLocalMember(new SourceString(id));
+      } else {
+        result = null;
+      }
+    } else {
+      // Lookup [: id :].
+      result = scope.lookup(new SourceString(name));
+    }
+    if (result == null || result.isPrefix()) return null;
+    return _convertElementToDeclarationMirror(mirrors, result);
+  }
+
+  bool operator ==(var other) {
+    if (identical(this, other)) return true;
+    if (other == null) return false;
+    if (other is! Dart2JsElementMirror) return false;
+    return _element == other._element &&
+           owner == other.owner;
+  }
+
+  int get hashCode {
+    return 13 * _element.hashCode + 17 * owner.hashCode;
+  }
 }
 
 abstract class Dart2JsMemberMirror extends Dart2JsElementMirror
     implements MemberMirror {
 
   Dart2JsMemberMirror(Dart2JsMirrorSystem system, Element element)
       : super(system, element);
 
   bool get isConstructor => false;
 
@@ skipping 273 matching lines @@
 
 class Dart2JsParameterMirror extends Dart2JsMemberMirror
     implements ParameterMirror {
   final MethodMirror _method;
   final bool isOptional;
   final bool isNamed;
 
   factory Dart2JsParameterMirror(Dart2JsMirrorSystem system,
                                  MethodMirror method,
                                  VariableElement element,
-                                 bool isOptional,
-                                 bool isNamed) {
+                                 {bool isOptional: false,
+                                  bool isNamed: false}) {
     if (element is FieldParameterElement) {
       return new Dart2JsFieldParameterMirror(system,
           method, element, isOptional, isNamed);
     }
     return new Dart2JsParameterMirror._normal(system,
         method, element, isOptional, isNamed);
   }
 
   Dart2JsParameterMirror._normal(Dart2JsMirrorSystem system,
                          this._method,
@@ skipping 698 matching lines @@
 
   bool get isRedirectingConstructor => _kind == Dart2JsMethodKind.REDIRECTING;
 
   bool get isFactoryConstructor => _kind == Dart2JsMethodKind.FACTORY;
 
   bool get isGetter => _kind == Dart2JsMethodKind.GETTER;
 
   bool get isSetter => _kind == Dart2JsMethodKind.SETTER;
 
   bool get isOperator => _kind == Dart2JsMethodKind.OPERATOR;
+
+  DeclarationMirror lookupInScope(String name) {
+    for (ParameterMirror parameter in parameters) {
+      if (parameter.simpleName == name) {
+        return parameter;
+      }
+    }
+    return super.lookupInScope(name);
+  }
 }
 
 class Dart2JsFieldMirror extends Dart2JsMemberMirror implements VariableMirror {
   Dart2JsContainerMirror _objectMirror;
   VariableElement _variable;
 
   Dart2JsFieldMirror(Dart2JsContainerMirror objectMirror,
                      VariableElement variable)
       : this._objectMirror = objectMirror,
         this._variable = variable,
@@ skipping 251 matching lines @@
     return [new Dart2JsClassMirror.fromLibrary(library, classElement)];
   } else if (e.isTypedef()) {
     return [new Dart2JsTypedefMirror.fromLibrary(
           library, e.computeType(library.mirrors.compiler))];
   } else {
     return _convertElementMemberToMemberMirrors(library, e);
   }
 }
 
 /**
+ * Converts [element] into its corresponding [DeclarationMirror], if any.
+ *
+ * If [element] is an [AbstractFieldElement] the mirror for its getter is
+ * returned or, if not present, the mirror for its setter.
+ */
+DeclarationMirror _convertElementToDeclarationMirror(Dart2JsMirrorSystem system,
+                                                     Element element) {
+  if (element.isTypeVariable()) {
+    return new Dart2JsTypeVariableMirror(
+        system, element.computeType(system.compiler));
+  }
+
+  Dart2JsLibraryMirror library = system._libraryMap[element.getLibrary()];
+  if (element.isLibrary()) return library;
+  if (element.isTypedef()) {
+    return new Dart2JsTypedefMirror.fromLibrary(
+        library, element.computeType(system.compiler));
+  }
+
+  Dart2JsContainerMirror container = library;
+  if (element.getEnclosingClass() != null) {
+    container = new Dart2JsClassMirror.fromLibrary(
+        library, element.getEnclosingClass());
+  }
+  if (element.isClass()) return container;
+  if (element.isParameter()) {
+    MethodMirror method = _convertElementMethodToMethodMirror(
+        container, element.getOutermostEnclosingMemberOrTopLevel());
+    // TODO(johnniwinther): Find the right info for [isOptional] and [isNamed].
+    return new Dart2JsParameterMirror(
+        system, method, element, isOptional: false, isNamed: false);
+  }
+  Iterable<MemberMirror> members =
+      _convertElementMemberToMemberMirrors(container, element);
+  if (members.isEmpty) return null;
+  return members.first;
+}
+
+/**
  * Experimental API for accessing compilation units defined in a
  * library.
  */
 // TODO(ahe): Superclasses? Is this really a mirror?
 class Dart2JsCompilationUnitMirror extends Dart2JsMirror {
   final Dart2JsLibraryMirror _library;
   final CompilationUnitElement _element;
 
   Dart2JsCompilationUnitMirror(this._element, this._library);
 
@@ skipping 19 matching lines @@
  *
  * All API in this class is experimental.
  */
 class BackDoor {
   /// Return the compilation units comprising [library].
   static List<Mirror> compilationUnitsOf(Dart2JsLibraryMirror library) {
     return library._library.compilationUnits.toList().map(
         (cu) => new Dart2JsCompilationUnitMirror(cu, library)).toList();
   }
 }