Compute source spans for IR nodes and J/K-elements

pkg/compiler/lib/src/kernel/element_map_impl.dart

 // Copyright (c) 2017, 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 dart2js.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../common/names.dart' show Identifiers;
@@ skipping 107 matching lines @@
   }
 
   LibraryEntity get _mainLibrary {
     return _env.mainMethod != null
         ? _getLibrary(_env.mainMethod.enclosingLibrary)
         : null;
   }
 
   Iterable<LibraryEntity> get _libraries;
 
+  SourceSpan _getSourceSpanFromTreeNode(ir.TreeNode node) {
+    ir.Location location;

[Siggi Cherem (dart-lang), 2017/07/07 19:25:02]

Let's store here just the Uri, and only use location within the loop.

Ideally, I'd like to not use Location - but it is true that right now it is the
simplest way to get the fileUri. The alternative would be walk up the tree until
we are in a procedure/field/class/library which stores a fileUri.

[Johnni Winther, 2017/07/11 08:06:59]

Done.
Long-term we should use Location (i.e. change SourceSpan to take line/position
info). Added a TODO.

[Siggi Cherem (dart-lang), 2017/07/11 19:04:55]

I'd like to use package:source_span for this (maybe kernel should switch to use
that too :))

I especially don't want to compute line/position here, but defer that to the
source-span logic.

+    int offset;
+    while (node != null) {
+      if (node.fileOffset != ir.TreeNode.noOffset) {
+        offset = node.fileOffset;
+        location = node.location;
+        break;
+      }
+      node = node.parent;
+    }
+    if (location != null) {
+      return new SourceSpan(Uri.parse(location.file), offset, offset + 1);
+    }
+    return null;
+  }
+
+  SourceSpan getSourceSpan(Spannable spannable, Entity currentElement) {
+    SourceSpan fromSpannable(Spannable spannable) {
+      if (spannable is IndexedLibrary &&
+          spannable.libraryIndex < _libraryEnvs.length) {
+        LibraryEnv env = _libraryEnvs[spannable.libraryIndex];
+        return _getSourceSpanFromTreeNode(env.library);
+      } else if (spannable is IndexedClass &&
+          spannable.classIndex < _classEnvs.length) {
+        ClassEnv env = _classEnvs[spannable.classIndex];
+        return _getSourceSpanFromTreeNode(env.cls);
+      } else if (spannable is IndexedMember &&
+          spannable.memberIndex < _memberData.length) {
+        MemberData data = _memberData[spannable.memberIndex];
+        return _getSourceSpanFromTreeNode(data.node);

[Siggi Cherem (dart-lang), 2017/07/07 19:25:02]

there is not a common interface for these in kernel, but my understanding is
that all 3: library, class, and members will have a fileUri directly on it and
most likely we don't need to walk up the tree from them.

[Johnni Winther, 2017/07/11 08:06:59]

They might, but MemberData.node might be a function expression so we need to
search anyway.

+      }
+      return null;
+    }
+
+    SourceSpan sourceSpan = fromSpannable(spannable);
+    sourceSpan ??= fromSpannable(currentElement);
+    return sourceSpan;
+  }
+
   LibraryEntity lookupLibrary(Uri uri) {
     LibraryEnv libraryEnv = _env.lookupLibrary(uri);
     if (libraryEnv == null) return null;
     return _getLibrary(libraryEnv.library, libraryEnv);
   }
 
   String _getLibraryName(IndexedLibrary library) {
     assert(checkFamily(library));
     LibraryEnv libraryEnv = _libraryEnvs[library.libraryIndex];
     return libraryEnv.library.name ?? '';
@@ skipping 391 matching lines @@
   }
 
   Iterable<InterfaceType> _getInterfaces(IndexedClass cls) {
     assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureSupertypes(cls, data);
     return data.interfaces;
   }
 
   Spannable _getSpannable(MemberEntity member, ir.Node node) {
-    return member;
+    SourceSpan sourceSpan;
+    if (node is ir.TreeNode) {
+      sourceSpan = _getSourceSpanFromTreeNode(node);
+    }
+    sourceSpan ??= getSourceSpan(member, null);
+    return sourceSpan;
   }
 
   ir.Member _getMemberNode(covariant IndexedMember member) {
     assert(checkFamily(member));
     return _memberData[member.memberIndex].node;
   }
 
   ir.Class _getClassNode(covariant IndexedClass cls) {
     assert(checkFamily(cls));
     return _classEnvs[cls.classIndex].cls;
@@ skipping 1375 matching lines @@
   @override
   ir.Member getMemberNode(MemberEntity member) {
     return _getMemberNode(member);
   }
 
   @override
   ir.Class getClassNode(ClassEntity cls) {
     return _getClassNode(cls);
   }
 }