Non-format-changing kernel offset changes

pkg/kernel/lib/analyzer/ast_from_analyzer.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.ast_from_analyzer;
 
 import '../ast.dart' as ast;
 import '../frontend/accessors.dart';
 import '../frontend/super_initializers.dart';
 import '../log.dart';
 import '../type_algebra.dart';
@@ skipping 454 matching lines @@
       }
     }
     var returnType = element is ConstructorElement
         ? const ast.VoidType()
         : buildType(element.returnType);
     return new ast.FunctionNode(null,
         typeParameters: typeParameters,
         positionalParameters: positional,
         namedParameters: named,
         requiredParameterCount: requiredParameterCount,
-        returnType: returnType);
+        returnType: returnType)..fileOffset = element.nameOffset;
   }
 }
 
 class ExpressionScope extends TypeScope {
   ast.Library currentLibrary;
   final Map<LocalElement, ast.VariableDeclaration> localVariables =
       <LocalElement, ast.VariableDeclaration>{};
 
   ExpressionBuilder _expressionBuilder;
   StatementBuilder _statementBuilder;
@@ skipping 73 matching lines @@
 
         case ParameterKind.POSITIONAL:
           positional.add(declaration);
           break;
 
         case ParameterKind.NAMED:
           named.add(declaration);
           break;
       }
     }
+    int offset = formalParameters?.offset ?? body.offset;
+    int endOffset = body.endToken.offset;
     return new ast.FunctionNode(buildOptionalFunctionBody(body),
         typeParameters: typeParameters,
         positionalParameters: positional,
         namedParameters: named,
         requiredParameterCount: requiredParameterCount,
         returnType: buildOptionalTypeAnnotation(returnType) ??
             inferredReturnType ??
             const ast.DynamicType(),
         asyncMarker: getAsyncMarker(
-            isAsync: body.isAsynchronous, isStar: body.isGenerator));
+            isAsync: body.isAsynchronous, isStar: body.isGenerator))
+      ..fileOffset = offset
+      ..fileEndOffset = endOffset;
   }
 
   ast.Expression buildOptionalTopLevelExpression(Expression node) {
     return node == null ? null : buildTopLevelExpression(node);
   }
 
   ast.Expression buildTopLevelExpression(Expression node) {
     try {
       return _expressionBuilder.build(node);
     } on _CompilationError catch (e) {
@@ skipping 40 matching lines @@
         element is FunctionElement;
   }
 
   bool isConst(Element element) {
     return element is VariableElement && element.isConst;
   }
 
   ast.VariableDeclaration getVariableReference(LocalElement element) {
     return localVariables.putIfAbsent(element, () {
       return new ast.VariableDeclaration(element.name,
-          isFinal: isFinal(element), isConst: isConst(element));
+          isFinal: isFinal(element),
+          isConst: isConst(element))..fileOffset = element.nameOffset;
     });
   }
 
   ast.DartType getInferredVariableType(Element element) {
     if (!strongMode) return const ast.DynamicType();
     if (element is FunctionTypedElement) {
       return buildType(element.type);
     } else if (element is VariableElement) {
       return buildType(element.type);
     } else {
@@ skipping 243 matching lines @@
   LabelStack.many(this.labels, this.next);
 }
 
 class StatementBuilder extends GeneralizingAstVisitor<ast.Statement> {
   final ExpressionScope scope;
   LabelStack breakStack, continueStack;
 
   StatementBuilder(this.scope, [this.breakStack, this.continueStack]);
 
   ast.Statement build(Statement node) {
-    return node.accept(this);
+    ast.Statement result = node.accept(this);
+    result.fileOffset = _getOffset(node);
+    return result;
   }
 
   ast.Statement buildOptional(Statement node) {
-    return node?.accept(this);
+    ast.Statement result = node?.accept(this);
+    result?.fileOffset = _getOffset(node);
+    return result;
+  }
+
+  int _getOffset(AstNode node) {
+    return node.offset;
   }
 
   ast.Statement buildInScope(
       Statement node, LabelStack breakNode, LabelStack continueNode) {
     var oldBreak = this.breakStack;
     var oldContinue = this.continueStack;
     breakStack = breakNode;
     continueStack = continueNode;
     var result = build(node);
     this.breakStack = oldBreak;
@@ skipping 361 matching lines @@
     var declaration = node.functionDeclaration;
     var expression = declaration.functionExpression;
     LocalElement element = declaration.element as dynamic; // Cross cast.
     // TODO: Set a function type on the variable.
     return new ast.FunctionDeclaration(
         scope.makeVariableDeclaration(element),
         scope.buildFunctionNode(expression.parameters, expression.body,
             typeParameters: scope.buildOptionalTypeParameterList(
                 expression.typeParameters,
                 strongModeOnly: true),
-            returnType: declaration.returnType));
+            returnType: declaration.returnType))..fileOffset = node.offset;
   }
 
   @override
   visitStatement(Statement node) {
     return scope.internalError('Unhandled statement ${node.runtimeType}');
   }
 }
 
 class ExpressionBuilder
     extends GeneralizingAstVisitor /* <ast.Expression | Accessor> */ {
@@ skipping 13 matching lines @@
     if (node is MethodInvocation) {
       return node.methodName.offset;
     } else if (node is InstanceCreationExpression) {
       return node.constructorName.offset;
     } else if (node is BinaryExpression) {
       return node.operator.offset;
     } else if (node is PrefixedIdentifier) {
       return node.identifier.offset;
     } else if (node is AssignmentExpression) {
       return _getOffset(node.leftHandSide);
+    } else if (node is PropertyAccess) {
+      return node.propertyName.offset;
+    } else if (node is IsExpression) {
+      return node.isOperator.offset;
+    } else if (node is StringLiteral) {
+      // Use a catch-all for StringInterpolation and AdjacentStrings:
+      // the debugger stops at the end.
+      return node.end;
     }
     return node.offset;
   }
 
   Accessor buildLeftHandValue(Expression node) {
     var result = node.accept(this);
     if (result is Accessor) {
       return result;
     } else {
       return new ReadOnlyAccessor(result);
@@ skipping 13 matching lines @@
     if (operator == '=') {
       return leftHand.buildAssignment(rightHand, voidContext: voidContext);
     } else if (operator == '??=') {
       return leftHand.buildNullAwareAssignment(
           rightHand, scope.buildType(node.staticType),
           voidContext: voidContext);
     } else {
       // Cut off the trailing '='.
       var name = new ast.Name(operator.substring(0, operator.length - 1));
       return leftHand.buildCompoundAssignment(name, rightHand,
+          offset: node.offset,
           voidContext: voidContext,
           interfaceTarget: scope.resolveInterfaceMethod(node.staticElement));
     }
   }
 
   ast.Expression visitAwaitExpression(AwaitExpression node) {
     return new ast.AwaitExpression(build(node.expression));
   }
 
   ast.Arguments buildSingleArgument(Expression node) {
     return new ast.Arguments(<ast.Expression>[build(node)]);
   }
 
   ast.Expression visitBinaryExpression(BinaryExpression node) {
     String operator = node.operator.value();
     if (operator == '&&' || operator == '||') {
       return new ast.LogicalExpression(
           build(node.leftOperand), operator, build(node.rightOperand));
     }
     if (operator == '??') {
       ast.Expression leftOperand = build(node.leftOperand);
       if (leftOperand is ast.VariableGet) {
         return new ast.ConditionalExpression(
-            buildIsNull(leftOperand),
+            buildIsNull(leftOperand, offset: node.leftOperand.offset),
             build(node.rightOperand),
             new ast.VariableGet(leftOperand.variable),
             scope.getInferredType(node));
       } else {
         var variable = new ast.VariableDeclaration.forValue(leftOperand);
         return new ast.Let(
             variable,
             new ast.ConditionalExpression(
-                buildIsNull(new ast.VariableGet(variable)),
+                buildIsNull(new ast.VariableGet(variable),
+                    offset: leftOperand.fileOffset),
                 build(node.rightOperand),
                 new ast.VariableGet(variable),
                 scope.getInferredType(node)));
       }
     }
     bool isNegated = false;
     if (operator == '!=') {
       isNegated = true;
       operator = '==';
     }
@@ skipping 488 matching lines @@
       var receiver = makeOrReuseVariable(build(target));
       return makeLet(
           receiver,
           new ast.ConditionalExpression(
               buildIsNull(new ast.VariableGet(receiver)),
               new ast.NullLiteral(),
               buildDecomposableMethodInvocation(
                   new ast.VariableGet(receiver),
                   scope.buildName(node.methodName),
                   buildArgumentsForInvocation(node),
-                  element),
+                  element)..fileOffset = node.methodName.offset,
               scope.buildType(node.staticType)));
     } else {
       return buildDecomposableMethodInvocation(
           build(node.target),
           scope.buildName(node.methodName),
           buildArgumentsForInvocation(node),
           element);
     }
   }
 
@@ skipping 14 matching lines @@
   }
 
   ast.Expression visitPostfixExpression(PostfixExpression node) {
     String operator = node.operator.value();
     switch (operator) {
       case '++':
       case '--':
         var leftHand = buildLeftHandValue(node.operand);
         var binaryOperator = new ast.Name(operator[0]);
         return leftHand.buildPostfixIncrement(binaryOperator,
+            offset: node.offset,
             voidContext: isInVoidContext(node),
             interfaceTarget: scope.resolveInterfaceMethod(node.staticElement));
 
       default:
         return scope.internalError('Invalid postfix operator $operator');
     }
   }
 
   ast.Expression visitPrefixExpression(PrefixExpression node) {
     String operator = node.operator.value();
@@ skipping 13 matching lines @@
             scope.resolveInterfaceMethod(node.staticElement));
 
       case '!':
         return new ast.Not(build(node.operand));
 
       case '++':
       case '--':
         var leftHand = buildLeftHandValue(node.operand);
         var binaryOperator = new ast.Name(operator[0]);
         return leftHand.buildPrefixIncrement(binaryOperator,
+            offset: node.offset,
             interfaceTarget: scope.resolveInterfaceMethod(node.staticElement));
 
       default:
         return scope.internalError('Invalid prefix operator $operator');
     }
   }
 
   visitPropertyAccess(PropertyAccess node) {
     Element element = node.propertyName.staticElement;
     Element auxiliary = node.propertyName.auxiliaryElements?.staticElement;
@@ skipping 371 matching lines @@
     node.accept(this);
   }
 
   /// Builds an empty class for broken classes that have no AST.
   ///
   /// This should only be used to recover from a compile-time error.
   void buildBrokenClass() {
     currentClass.name = element.name;
     currentClass.supertype = scope.getRootClassReference().asRawSupertype;
     currentClass.constructors.add(
-        new ast.Constructor(new ast.FunctionNode(new ast.InvalidStatement())));
+        new ast.Constructor(new ast.FunctionNode(new ast.InvalidStatement()))
+          ..fileOffset = element.nameOffset);
   }
 
   void addAnnotations(List<Annotation> annotations) {
     // Class type parameters are not in scope in the annotation list.
     for (var annotation in annotations) {
       currentClass.addAnnotation(annotationScope.buildAnnotation(annotation));
     }
   }
 
   void _buildMemberBody(ast.Member member, Element element, AstNode node) {
@@ skipping 128 matching lines @@
     var parameter = new ast.VariableDeclaration('index', type: intType);
     var function = new ast.FunctionNode(new ast.EmptyStatement(),
         positionalParameters: [parameter]);
     var superConstructor = scope.loader.getRootClassConstructorReference();
     var constructor = new ast.Constructor(function,
         name: new ast.Name(''),
         isConst: true,
         initializers: [
           new ast.FieldInitializer(indexField, new ast.VariableGet(parameter)),
           new ast.SuperInitializer(superConstructor, new ast.Arguments.empty())
-        ]);
+        ])..fileOffset = element.nameOffset;
     classNode.addMember(constructor);
     int index = 0;
     var enumConstantFields = <ast.Field>[];
     for (var constant in node.constants) {
       ast.Field field = scope.getMemberReference(constant.element);
       field.initializer = new ast.ConstructorInvocation(
           constructor, new ast.Arguments([new ast.IntLiteral(index)]),
           isConst: true)..parent = field;
       field.type = classNode.rawType;
       classNode.addMember(field);
@@ skipping 55 matching lines @@
   final MemberScope scope;
   final Element element;
   ast.Member get currentMember => scope.currentMember;
 
   MemberBodyBuilder(
       ReferenceLevelLoader loader, ast.Member member, this.element)
       : scope = new MemberScope(loader, member);
 
   void build(AstNode node) {
     if (node != null) {
+      currentMember.fileEndOffset = node.endToken.offset;
       node.accept(this);
     } else {
       buildBrokenMember();
     }
   }
 
   /// Builds an empty member.
   ///
   /// This should only be used to recover from a compile-time error.
   void buildBrokenMember() {
@@ skipping 274 matching lines @@
     if (list[i - 1].compareTo(item) == 0) {
       ++deleted;
     } else if (deleted > 0) {
       list[i - deleted] = item;
     }
   }
   if (deleted > 0) {
     list.length -= deleted;
   }
 }