Non-format-changing kernel offset changes

pkg/kernel/lib/analyzer/loader.dart

 // Copyright (c) 2016, 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 kernel.analyzer.loader;
 
 import 'dart:async';
 import 'dart:io' as io;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/file_system/file_system.dart';
@@ skipping 250 matching lines @@
   /// Returns the IR for a class, at a temporary loading level.
   ///
   /// The returned class has the correct name, flags, type parameter arity,
   /// and enclosing library.
   ast.Class getClassReference(ClassElement element) {
     var classNode = _classes[element];
     if (classNode != null) return classNode;
     _classes[element] = classNode = new ast.Class(
         name: element.name,
         isAbstract: element.isAbstract,
-        fileUri: '${element.source.uri}');
+        fileUri: '${element.source.uri}')..fileOffset = element.nameOffset;
     classNode.level = ast.ClassLevel.Temporary;
     var library = getLibraryReference(element.library);
     library.addClass(classNode);
     // Initialize type parameter list without bounds.
     for (var parameter in element.typeParameters) {
       var parameterNode = new ast.TypeParameter(parameter.name);
       _classTypeParameters[parameter] = parameterNode;
       classNode.typeParameters.add(parameterNode);
       parameterNode.parent = classNode;
     }
@@ skipping 28 matching lines @@
     }
     if (element.supertype != null) {
       ast.Supertype supertype = scope.buildSupertype(element.supertype);
       bool useSharedMixin = true;
       for (var mixin in mixins) {
         var mixinType = scope.buildSupertype(mixin);
         if (useSharedMixin &&
             areDistinctUnboundTypeVariables(supertype, mixinType)) {
           // Use a shared mixin application class for this library.
           var mixinClass = getSharedMixinApplicationClass(
-              scope.currentLibrary, supertype.classNode, mixinType.classNode);
+              scope.currentLibrary, supertype.classNode, mixinType.classNode)
+            ..fileOffset = element.nameOffset;

[asgerf, 2017/01/04 14:20:01]

What is the class offset used for?

Is it okay that the offset on the shared mixin class is just that of one of its
uses?

[jensj, 2017/01/05 09:07:55]

In general class offsets is used by Observatory to show the right lines from the
source file, when viewing info about a class. At the same time though, if I
remember correctly, it has to be a real offset (i.e. >= 0) or stuff will crash
(at least in some instances).

For dart files, object.cc's TokenPosition Class::ComputeEndTokenPos() seems to
return the position of the first use/creation/whatnot of the mixin class, and
then special case it (if (is_synthesized_class() || IsMixinApplication() ||
IsTopLevel())) to just show the first line...

I don't think we can really do that, unless we extend the class object (both on
dart and c++ side) to include the end token position, in which case we can set
it "correctly" here and get the same behavior for dill files as for dart files.
For now I'll change it to only set the offset, if it's not already set, that way
at least the first line shown will be the same line for dart and dill.

[asgerf, 2017/01/05 11:37:41]

Thanks for the clarification. Looks good to me then.

           supertype = new ast.Supertype(
               mixinClass,
               supertype.typeArguments.length > mixinType.typeArguments.length
                   ? supertype.typeArguments
                   : mixinType.typeArguments);
         } else {
           // Generate a new class specific for this mixin application.
           var freshParameters =
               getFreshTypeParameters(classNode.typeParameters);
           var mixinClass = new ast.Class(
               name: '${classNode.name}^${mixinType.classNode.name}',
               isAbstract: true,
               typeParameters: freshParameters.freshTypeParameters,
               supertype: freshParameters.substituteSuper(supertype),
               mixedInType: freshParameters.substituteSuper(mixinType),
-              fileUri: classNode.fileUri);
+              fileUri: classNode.fileUri)..fileOffset = element.nameOffset;
           mixinClass.level = ast.ClassLevel.Type;
           supertype = new ast.Supertype(mixinClass,
               classNode.typeParameters.map(makeTypeParameterType).toList());
           addMixinClassToLibrary(mixinClass, classNode.enclosingLibrary);
           // This class cannot be used from anywhere else, so don't try to
           // generate shared mixin applications using it.
           useSharedMixin = false;
         }
       }
       classNode.supertype = supertype;
@@ skipping 92 matching lines @@
         ConstructorElement constructor = element;
         if (constructor.isFactory) {
           return new ast.Procedure(
               _nameOfMember(constructor),
               ast.ProcedureKind.Factory,
               scope.buildFunctionInterface(constructor),
               isAbstract: false,
               isStatic: true,
               isExternal: constructor.isExternal,
               isConst: constructor.isConst,
-              fileUri: '${element.source.uri}');
+              fileUri: '${element.source.uri}')
+            ..fileOffset = element.nameOffset;
         }
         return new ast.Constructor(scope.buildFunctionInterface(constructor),
             name: _nameOfMember(element),
             isConst: constructor.isConst,
-            isExternal: constructor.isExternal);
+            isExternal: constructor.isExternal)
+          ..fileOffset = element.nameOffset;
 
       case ElementKind.FIELD:
       case ElementKind.TOP_LEVEL_VARIABLE:
         VariableElement variable = element;
         return new ast.Field(_nameOfMember(variable),
             isStatic: variable.isStatic,
             isFinal: variable.isFinal,
             isConst: variable.isConst,
             type: scope.buildType(variable.type),
             fileUri: '${element.source.uri}')..fileOffset = element.nameOffset;
 
       case ElementKind.METHOD:
       case ElementKind.GETTER:
       case ElementKind.SETTER:
       case ElementKind.FUNCTION:
         if (element is FunctionElement &&
             element.enclosingElement is! CompilationUnitElement) {
           throw 'Function $element is nested in ${element.enclosingElement} '
               'and hence is not a member';
         }
         ExecutableElement executable = element;
         return new ast.Procedure(
             _nameOfMember(element),
             _procedureKindOf(executable),
             scope.buildFunctionInterface(executable),
             isAbstract: executable.isAbstract,
             isStatic: executable.isStatic,
             isExternal: executable.isExternal,
-            fileUri: '${element.source.uri}');
+            fileUri: '${element.source.uri}')..fileOffset = element.nameOffset;
 
       default:
         throw 'Unexpected member kind: $element';
     }
   }
 
   ast.ProcedureKind _procedureKindOf(ExecutableElement element) {
     if (element is PropertyAccessorElement) {
       return element.isGetter
           ? ast.ProcedureKind.Getter
@@ skipping 368 matching lines @@
   AnalysisContext context = AnalysisEngine.instance.createAnalysisContext()
     ..sourceFactory = new SourceFactory(resolvers)
     ..analysisOptions = createAnalysisOptions(options.strongMode);
 
   options.declaredVariables.forEach((String name, String value) {
     context.declaredVariables.define(name, value);
   });
 
   return context;
 }