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));
+  Token getBeginToken() {
+    if (!_element.metadata.isEmpty) {
+      for (MetadataAnnotation metadata in _element.metadata) {
+        if (metadata.beginToken != null) {
+          return metadata.beginToken;
+        }
+      }
+    }
+    Node node = _element.parseNode(mirrors.compiler);

[ahe, 2013/01/03 18:58:21]

This is brittle as it can cause a parse error.  Ideally, you'd be able to
extract a span directly from the element.  For example, PartialClassElement has
two fields, beginToken and endToken.

The "original" partial elements (PartialFunctionElement and PartialClassElement
both record both begin and end tokens.  Partial elements that have been added
later do not (PartialTypedefElement and PartialMetadataAnnotation).  However, it
should be easy to fix that.

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

Added a TODO.

+    if (node == null) {
+      return _element.position();
+    }
+    return node.getBeginToken();
+  }
+
+  Token getEndToken() {
+    Node node = _element.parseNode(mirrors.compiler);
+    if (node == null) {
+      return _element.position();
+    }
+    return node.getBeginToken();
+  }
+
+  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;
+  Token getBeginToken() {

[ahe, 2013/01/03 18:58:21]

Document what you do here.

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

Done.

     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;
+  }
+
+  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 159 matching lines @@
   Future<InstanceMirror> getField(String fieldName) {
     _ensureFieldMap();
     Constant fieldConstant = _fieldMap[fieldName];
     if (fieldConstant != null) {
       return new Future<InstanceMirror>.immediate(
           _convertConstantToInstanceMirror(mirrors, fieldConstant));
     }
     return super.getField(fieldName);
   }
 }