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 29 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);
+          if (mixinClass.fileOffset < 0) {
+            mixinClass.fileOffset = element.nameOffset;
+          }
           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;
 }