Add SourceFileEdit.time field.

pkg/analysis_server/lib/src/services/correction/util.dart

 // Copyright (c) 2014, 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 services.src.correction.util;
 
 import 'dart:math';
 
-import 'package:analysis_server/src/protocol.dart' show SourceEdit;
+import 'package:analysis_server/src/protocol.dart' show SourceChange,
+    SourceEdit;
 import 'package:analysis_server/src/services/correction/source_range.dart';
 import 'package:analysis_server/src/services/correction/strings.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
 import 'package:analyzer/src/generated/source.dart';
 
 
+void addElementSourceChange(SourceChange change, Element element,
+    SourceEdit edit) {
+  AnalysisContext context = element.context;
+  Source source = element.source;
+  addSourceChange(change, context, source, edit);
+}
+
+
+void addSourceChange(SourceChange change, AnalysisContext context,
+    Source source, SourceEdit edit) {
+  String file = source.fullName;
+  int fileStamp = context.getModificationStamp(source);
+  change.addEdit(file, fileStamp, edit);
+}
+
+
 /**
  * @return <code>true</code> if given [List]s are identical at given position.
  */
 bool allListsIdentical(List<List> lists, int position) {
   Object element = lists[0][position];
   for (List list in lists) {
     if (list[position] != element) {
       return false;
     }
   }
@@ skipping 43 matching lines @@
 
 
 /**
  * Return the name of the [Element] kind.
  */
 String getElementKindName(Element element) {
   return element.kind.displayName;
 }
 
 
+
 /**
  * Returns the name to display in the UI for the given [Element].
  */
 String getElementQualifiedName(Element element) {
   ElementKind kind = element.kind;
   if (kind == ElementKind.FIELD || kind == ElementKind.METHOD) {
     return '${element.enclosingElement.displayName}.${element.displayName}';
   } else {
     return element.displayName;
   }
 }
 
-
 /**
  * If the given [AstNode] is in a [ClassDeclaration], returns the
  * [ClassElement]. Otherwise returns `null`.
  */
 ClassElement getEnclosingClassElement(AstNode node) {
   ClassDeclaration enclosingClassNode =
       node.getAncestor((node) => node is ClassDeclaration);
   if (enclosingClassNode != null) {
     return enclosingClassNode.element;
   }
   return null;
 }
 
 
-
 /**
  * Returns a class or an unit member enclosing the given [node].
  */
 AstNode getEnclosingClassOrUnitMember(AstNode node) {
   AstNode member = node;
   while (node != null) {
     if (node is ClassDeclaration) {
       return member;
     }
     if (node is CompilationUnit) {
       return member;
     }
     member = node;
     node = node.parent;
   }
   return null;
 }
 
+
 /**
  * @return the [ExecutableElement] of the enclosing executable [AstNode].
  */
 ExecutableElement getEnclosingExecutableElement(AstNode node) {
   while (node != null) {
     if (node is FunctionDeclaration) {
       return node.element;
     }
     if (node is ConstructorDeclaration) {
       return node.element;
@@ skipping 20 matching lines @@
     }
     if (node is MethodDeclaration) {
       return node;
     }
     node = node.parent;
   }
   return null;
 }
 
 
+
 /**
  * Returns [getExpressionPrecedence] for the parent of [node],
  * or `0` if the parent node is [ParenthesizedExpression].
  *
  * The reason is that `(expr)` is always executed after `expr`.
  */
 int getExpressionParentPrecedence(AstNode node) {
   AstNode parent = node.parent;
   if (parent is ParenthesizedExpression) {
     return 0;
   }
   return getExpressionPrecedence(parent);
 }
 
 
 /**
  * Returns the precedence of [node] it is an [Expression], negative otherwise.
  */
 int getExpressionPrecedence(AstNode node) {
   if (node is Expression) {
     return node.precedence;
   }
   return -1000;
 }
 
 
-
 /**
  * Returns the namespace of the given [ImportElement].
  */
 Map<String, Element> getImportNamespace(ImportElement imp) {
   NamespaceBuilder builder = new NamespaceBuilder();
   Namespace namespace = builder.createImportNamespaceForDirective(imp);
   return namespace.definedNames;
 }
 
 
 /**
  * Returns the line prefix from the given source, i.e. basically just a
  * whitespace prefix of the given [String].
  */
 String getLinePrefix(String line) {
   int index = 0;
   while (index < line.length) {
     int c = line.codeUnitAt(index);
     if (!isWhitespace(c)) {
       break;
     }
     index++;
   }
   return line.substring(0, index);
 }
 
-
 /**
  * @return the [LocalVariableElement] or [ParameterElement] if given
  *         [SimpleIdentifier] is the reference to local variable or parameter, or
  *         <code>null</code> in the other case.
  */
 VariableElement getLocalOrParameterVariableElement(SimpleIdentifier node) {
   Element element = node.staticElement;
   if (element is LocalVariableElement) {
     return element;
   }
   if (element is ParameterElement) {
     return element;
   }
   return null;
 }
 
-
 /**
  * @return the [LocalVariableElement] if given [SimpleIdentifier] is the reference to
  *         local variable, or <code>null</code> in the other case.
  */
 LocalVariableElement getLocalVariableElement(SimpleIdentifier node) {
   Element element = node.staticElement;
   if (element is LocalVariableElement) {
     return element;
   }
   return null;
 }
 
+
 /**
  * @return the nearest common ancestor [AstNode] of the given [AstNode]s.
  */
 AstNode getNearestCommonAncestor(List<AstNode> nodes) {
   // may be no nodes
   if (nodes.isEmpty) {
     return null;
   }
   // prepare parents
   List<List<AstNode>> parents = [];
   for (AstNode node in nodes) {
     parents.add(getParents(node));
   }
   // find min length
   int minLength = 1 << 20;
   for (List<AstNode> parentList in parents) {
     minLength = min(minLength, parentList.length);
   }
   // find deepest parent
   int i = 0;
   for ( ; i < minLength; i++) {
     if (!allListsIdentical(parents, i)) {
       break;
     }
   }
   return parents[0][i - 1];
 }
 
+
 /**
  * Returns the [Expression] qualifier if given node is the name part of a
  * [PropertyAccess] or a [PrefixedIdentifier]. Maybe `null`.
  */
 Expression getNodeQualifier(SimpleIdentifier node) {
   AstNode parent = node.parent;
   if (parent is PropertyAccess) {
     PropertyAccess propertyAccess = parent;
     if (identical(propertyAccess.propertyName, node)) {
       return propertyAccess.target;
@@ skipping 98 matching lines @@
 }
 
 
 /**
  * Returns the [String] content of the given [Source].
  */
 String getSourceContent(AnalysisContext context, Source source) {
   return context.getContents(source).data;
 }
 
-
 /**
  * Returns the given [Statement] if not a [Block], or all the children
  * [Statement]s if a [Block].
  */
 List<Statement> getStatements(Statement statement) {
   if (statement is Block) {
     return statement.statements;
   }
   return [statement];
 }
 
 
 /**
  * Checks if the given [Element]'s display name equals to the given name.
  */
 bool hasDisplayName(Element element, String name) {
   if (element == null) {
     return false;
   }
   return element.displayName == name;
 }
 
+
 /**
  * Checks if the given [PropertyAccessorElement] is an accessor of a
  * [FieldElement].
  */
 bool isFieldAccessorElement(PropertyAccessorElement accessor) {
   return accessor != null && accessor.variable is FieldElement;
 }
 
 
 /**
@@ skipping 951 matching lines @@
 
   @override
   Object visitExpression(Expression node) {
     if (node is BinaryExpression && node.operator.type == groupOperatorType) {
       return super.visitNode(node);
     }
     operands.add(node);
     return null;
   }
 }