Refactor location computation in dart2js mirrors.

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:io';
 import 'dart:uri';
 
 import '../../compiler.dart' as diagnostics;
@@ skipping 415 matching lines @@
 
 
 //------------------------------------------------------------------------------
 // Dart2Js specific extensions of mirror interfaces
 //------------------------------------------------------------------------------
 
 abstract class Dart2JsMirror implements Mirror {
   Dart2JsMirrorSystem get mirrors;
 }
 
-abstract class Dart2JsDeclarationMirror
-    implements Dart2JsMirror, DeclarationMirror {
+abstract class Dart2JsDeclarationMirror extends Dart2JsMirror
+    implements DeclarationMirror {
 
   bool get isTopLevel => owner != null && owner is LibraryMirror;
 
   bool get isPrivate => _isPrivate(simpleName);
+
+  /**
+   * Returns the first token for the source of this declaration.
+   */
+  Token getBeginToken();
+
+  /**
+   * Returns the last token for the source of this declaration.
+   */
+  Token getEndToken();
+
+  /**
+   * Returns the script for the source of this declaration.
+   */
+  Script getScript();
+
+  SourceLocation get location {
+    Token beginToken = getBeginToken();
+    Script script = getScript();
+    SourceSpan span;
+    if (beginToken == null) {
+      span = new SourceSpan(script.uri, 0, 0);
+    } else {
+      Token endToken = getEndToken();
+      span = mirrors.compiler.spanFromTokens(beginToken, endToken, script.uri);
+    }
+    return new Dart2JsSourceLocation(script, span);
+  }
 }
 
 abstract class Dart2JsMemberMirror extends Dart2JsElementMirror
     implements MemberMirror {
 
   Dart2JsMemberMirror(Dart2JsMirrorSystem system, Element element)
       : super(system, element);
 
   bool get isConstructor => false;
 
@@ skipping 18 matching lines @@
 
   Dart2JsElementMirror(this.mirrors, this._element) {
     assert (mirrors != null);
     assert (_element != null);
   }
 
   String get simpleName => _element.name.slowToString();
 
   String get displayName => simpleName;
 
-  SourceLocation get location => new Dart2JsSourceLocation(
-      _element.getCompilationUnit().script,
-      mirrors.compiler.spanFromElement(_element));
+  /**
+   * Computes the first token for this declaration using the first metadata
+   * annotation, the begin token of the element node or element position as
+   * indicator.
+   */
+  Token getBeginToken() {
+    if (!_element.metadata.isEmpty) {
+      for (MetadataAnnotation metadata in _element.metadata) {
+        if (metadata.beginToken != null) {
+          return metadata.beginToken;
+        }
+      }
+    }
+    // TODO(johnniwinther): Avoid calling [parseNode].
+    Node node = _element.parseNode(mirrors.compiler);
+    if (node == null) {
+      return _element.position();
+    }
+    return node.getBeginToken();
+  }
+
+  /**
+   * Computes the last token for this declaration using the end token of the
+   * element node or element position as indicator.
+   */
+  Token getEndToken() {
+    // TODO(johnniwinther): Avoid calling [parseNode].
+    Node node = _element.parseNode(mirrors.compiler);
+    if (node == null) {
+      return _element.position();
+    }
+    return node.getEndToken();
+  }
+
+  Script getScript() => _element.getCompilationUnit().script;
 
   String toString() => _element.toString();
 
   int get hashCode => qualifiedName.hashCode;
 
   List<InstanceMirror> get metadata {
     if (_metadata == null) {
       _metadata = <InstanceMirror>[];
       for (MetadataAnnotation metadata in _element.metadata) {
         metadata.ensureResolved(mirrors.compiler);
         _metadata.add(
             _convertConstantToInstanceMirror(mirrors, metadata.value));
       }
     }
     // TODO(johnniwinther): Return an unmodifiable list instead.
     return new List<InstanceMirror>.from(_metadata);
   }
 }
 
-abstract class Dart2JsProxyMirror extends Dart2JsDeclarationMirror {
-  final Dart2JsMirrorSystem mirrors;
-
-  Dart2JsProxyMirror(this.mirrors);
-
-  String get displayName => simpleName;
-
-  int get hashCode => qualifiedName.hashCode;
-}
-
 //------------------------------------------------------------------------------
 // Mirror system implementation.
 //------------------------------------------------------------------------------
 
-class Dart2JsMirrorSystem implements MirrorSystem, Dart2JsMirror {
+class Dart2JsMirrorSystem implements MirrorSystem {
   final api.Compiler compiler;
   Map<String, Dart2JsLibraryMirror> _libraries;
   Map<LibraryElement, Dart2JsLibraryMirror> _libraryMap;
 
   Dart2JsMirrorSystem(this.compiler)
     : _libraryMap = new Map<LibraryElement, Dart2JsLibraryMirror>();
 
   void _ensureLibraries() {
     if (_libraries == null) {
       _libraries = <String, Dart2JsLibraryMirror>{};
@@ skipping 145 matching lines @@
         }
       });
     }
   }
 
   Map<String, ClassMirror> get classes {
     _ensureClasses();
     return new ImmutableMapWrapper<String, ClassMirror>(_classes);
   }
 
-  SourceLocation get location {
-    var script = _library.getCompilationUnit().script;
-    SourceSpan span;
+  /**
+   * Computes the first token of this library using the first metadata
+   * annotation or the first library tag as indicator.
+   */
+  Token getBeginToken() {
+    if (!_element.metadata.isEmpty) {
+      for (MetadataAnnotation metadata in _element.metadata) {
+        if (metadata.beginToken != null) {
+          return metadata.beginToken;
+        }
+      }
+    }
     if (_library.libraryTag != null) {
-      span = mirrors.compiler.spanFromNode(_library.libraryTag, script.uri);
-    } else {
-      span = new SourceSpan(script.uri, 0, 0);
+      return _library.libraryTag.getBeginToken();
+    } else if (!_library.tags.isEmpty) {
+      return _library.tags.reverse().head.getBeginToken();
     }
-    return new Dart2JsSourceLocation(script, span);
+    return null;
+  }
+
+  /**
+   * Computes the first token of this library using the last library tag as
+   * indicator.
+   */
+  Token getEndToken() {
+    if (!_library.tags.isEmpty) {
+      return _library.tags.head.getEndToken();
+    }
+    return null;
   }
 }
 
 class Dart2JsSourceLocation implements SourceLocation {
   final Script _script;
   final SourceSpan _span;
   int _line;
   int _column;
 
   Dart2JsSourceLocation(this._script, this._span);
@@ skipping 161 matching lines @@
 
   Dart2JsClassMirror.fromLibrary(Dart2JsLibraryMirror library,
                                  ClassElement _class)
       : this.library = library,
         super(library.mirrors, _class);
 
   DeclarationMirror get owner => library;
 
   String get qualifiedName => '${library.qualifiedName}.${simpleName}';
 
-  SourceLocation get location {
-    if (_class is PartialClassElement) {
-      var node = _class.parseNode(mirrors.compiler);
-      if (node != null) {
-        var script = _class.getCompilationUnit().script;
-        var span = mirrors.compiler.spanFromNode(node, script.uri);
-        return new Dart2JsSourceLocation(script, span);
-      }
-    }
-    return super.location;
-  }
-
   void _ensureMembers() {
     if (_members == null) {
       _members = <String, Dart2JsMemberMirror>{};
       _class.forEachMember((_, e) {
         for (var member in _convertElementMemberToMemberMirrors(this, e)) {
           assert(!_members.containsKey(member.simpleName));
           _members[member.simpleName] = member;
         }
       });
     }
@@ skipping 104 matching lines @@
 
   Dart2JsTypedefMirror.fromLibrary(Dart2JsLibraryMirror library,
                                    TypedefType _typedef)
       : this._library = library,
         super(library.mirrors, _typedef);
 
   TypedefType get _typedef => _type;
 
   String get qualifiedName => '${library.qualifiedName}.${simpleName}';
 
-  SourceLocation get location {
-    var node = _typedef.element.parseNode(_diagnosticListener);
-    if (node != null) {
-      var script = _typedef.element.getCompilationUnit().script;
-      var span = mirrors.compiler.spanFromNode(node, script.uri);
-      return new Dart2JsSourceLocation(script, span);
-    }
-    return super.location;
-  }
-
   LibraryMirror get library => _library;
 
   bool get isTypedef => true;
 
   List<TypeMirror> get typeArguments {
     throw new UnsupportedError(
         'Declarations do not have type arguments');
   }
 
   List<TypeVariableMirror> get typeVariables {
@@ skipping 88 matching lines @@
     }
     return qualifiedName == other.qualifiedName;
   }
 }
 
 
 //------------------------------------------------------------------------------
 // Types
 //------------------------------------------------------------------------------
 
-abstract class Dart2JsTypeElementMirror extends Dart2JsProxyMirror
+abstract class Dart2JsTypeElementMirror extends Dart2JsElementMirror
     implements Dart2JsTypeMirror {
   final DartType _type;
-  List<InstanceMirror> _metadata;
 
-  Dart2JsTypeElementMirror(Dart2JsMirrorSystem system, this._type)
-    : super(system);
+  Dart2JsTypeElementMirror(Dart2JsMirrorSystem system, DartType type)
+    : super(system, type.element),
+      this._type = type;
 
   String get simpleName => _type.name.slowToString();
 
-  SourceLocation get location {
-    var script = _type.element.getCompilationUnit().script;
-    return new Dart2JsSourceLocation(script,
-        mirrors.compiler.spanFromElement(_type.element));
-  }
-
   DeclarationMirror get owner => library;
 
   LibraryMirror get library {
     return mirrors._getLibrary(_type.element.getLibrary());
   }
 
   bool get isObject => false;
 
   bool get isVoid => false;
 
   bool get isDynamic => false;
 
   bool get isTypeVariable => false;
 
   bool get isTypedef => false;
 
   bool get isFunction => false;
 
-  String toString() => _type.element.toString();
+  String toString() => _type.toString();
 
   Map<String, MemberMirror> get members => const <String, MemberMirror>{};
 
   Map<String, MethodMirror> get constructors => const <String, MethodMirror>{};
 
   Map<String, MethodMirror> get methods => const <String, MethodMirror>{};
 
   Map<String, MethodMirror> get getters => const <String, MethodMirror>{};
 
   Map<String, MethodMirror> get setters => const <String, MethodMirror>{};
 
   Map<String, VariableMirror> get variables => const <String, VariableMirror>{};
 
   ClassMirror get defaultFactory => null;
-
-  // TODO(johnniwinther): Should a type show the metadata of its declaration?
-  List<InstanceMirror> get metadata {
-    if (_metadata == null) {
-      var _metadata = <InstanceMirror>[];
-      for (MetadataAnnotation metadata in _type.element.metadata) {
-        metadata.ensureResolved(mirrors.compiler);
-        _metadata.add(
-            _convertConstantToInstanceMirror(mirrors, metadata.value));
-      }
-    }
-    // TODO(johnniwinther): Return an unmodifiable list instead.
-    return new List<InstanceMirror>.from(_metadata);
-  }
 }
 
 class Dart2JsInterfaceTypeMirror extends Dart2JsTypeElementMirror
     implements ClassMirror {
   List<TypeMirror> _typeArguments;
 
   Dart2JsInterfaceTypeMirror(Dart2JsMirrorSystem system,
                              InterfaceType interfaceType)
       : super(system, interfaceType);
 
@@ skipping 360 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;
-
-  SourceLocation get location {
-    var node = _function.parseNode(_diagnosticListener);
-    if (node != null) {
-      var script = _function.getCompilationUnit().script;
-      var span = mirrors.compiler.spanFromNode(node, script.uri);
-      return new Dart2JsSourceLocation(script, span);
-    }
-    return super.location;
-  }
-
 }
 
 class Dart2JsFieldMirror extends Dart2JsMemberMirror implements VariableMirror {
   Dart2JsContainerMirror _objectMirror;
   VariableElement _variable;
 
   Dart2JsFieldMirror(Dart2JsContainerMirror objectMirror,
                      VariableElement variable)
       : this._objectMirror = objectMirror,
         this._variable = variable,
@@ skipping 10 matching lines @@
 
   bool get isStatic => _variable.modifiers.isStatic();
 
   bool get isFinal => _variable.modifiers.isFinal();
 
   bool get isConst => _variable.modifiers.isConst();
 
   TypeMirror get type => _convertTypeToTypeMirror(mirrors,
       _variable.computeType(mirrors.compiler),
       mirrors.compiler.types.dynamicType);
-
-  SourceLocation get location {
-    var script = _variable.getCompilationUnit().script;
-    var node = _variable.variables.parseNode(_diagnosticListener);
-    if (node != null) {
-      var span = mirrors.compiler.spanFromNode(node, script.uri);
-      return new Dart2JsSourceLocation(script, span);
-    } else {
-      var span = mirrors.compiler.spanFromElement(_variable);
-      return new Dart2JsSourceLocation(script, span);
-    }
-  }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Mirrors on constant values used for metadata.
 ////////////////////////////////////////////////////////////////////////////////
 
 class Dart2JsConstantMirror extends InstanceMirror {
   final Dart2JsMirrorSystem mirrors;
   final Constant _constant;
 
@@ skipping 73 matching lines @@
 
   int get length => _constant.length;
 
   Future<InstanceMirror> operator[](int index) {
     if (index < 0) throw new RangeError('Negative index');
     if (index >= _constant.length) throw new RangeError('Index out of bounds');
     return new Future<InstanceMirror>.immediate(
         _convertConstantToInstanceMirror(mirrors, _constant.entries[index]));
   }
 }
 

[Johnni Winther, 2013/01/04 09:57:56]

The changes below are from https://codereview.chromium.org/11571058/ on which
this CL is based.

 class Dart2JsMapConstantMirror extends Dart2JsConstantMirror
     implements MapInstanceMirror {
   List<String> _listCache;
 
   Dart2JsMapConstantMirror(Dart2JsMirrorSystem mirrors,
                            MapConstant constant)
       : super(mirrors, constant);
 
   MapConstant get _constant => super._constant;
 
@@ skipping 64 matching lines @@
 
   Future<InstanceMirror> getField(String fieldName) {
     Constant fieldConstant = _fieldMap[fieldName];
     if (fieldConstant != null) {
       return new Future<InstanceMirror>.immediate(
           _convertConstantToInstanceMirror(mirrors, fieldConstant));
     }
     return super.getField(fieldName);
   }
 }