Remove timeStamp from the ChangeBuilder API

pkg/analysis_server/lib/src/services/correction/fix_internal.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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core';
 
 import 'package:analysis_server/plugin/edit/fix/fix_core.dart';
 import 'package:analysis_server/plugin/edit/fix/fix_dart.dart';
@@ skipping 88 matching lines @@
   GetTopLevelDeclarations getTopLevelDeclarations;
   CompilationUnit unit;
   AnalysisError error;
 
   /**
    * The analysis driver being used to perform analysis.
    */
   AnalysisDriver driver;
 
   String file;
-  int fileStamp;
   CompilationUnitElement unitElement;
   Source unitSource;
   LibraryElement unitLibraryElement;
   File unitLibraryFile;
   Folder unitLibraryFolder;
 
   final List<Fix> fixes = <Fix>[];
 
   CorrectionUtils utils;
   int errorOffset;
@@ skipping 10 matching lines @@
     resourceProvider = dartContext.resourceProvider;
     astProvider = dartContext.astProvider;
     getTopLevelDeclarations = dartContext.getTopLevelDeclarations;
     driver = dartContext.analysisDriver;
     // unit
     unit = dartContext.unit;
     unitElement = unit.element;
     unitSource = unitElement.source;
     // file
     file = unitSource.fullName;
-    fileStamp = _modificationStamp(file);
     // library
     unitLibraryElement = unitElement.library;
     String unitLibraryPath = unitLibraryElement.source.fullName;
     unitLibraryFile = resourceProvider.getFile(unitLibraryPath);
     unitLibraryFolder = unitLibraryFile.parent;
     // error
     error = dartContext.error;
   }
 
   DartType get coreTypeBool => _getCoreType('bool');
@@ skipping 15 matching lines @@
       if (driver.analysisOptions.strongMode) {
         _typeSystem = new StrongTypeSystemImpl(typeProvider);
       } else {
         _typeSystem = new TypeSystemImpl(typeProvider);
       }
     }
     return _typeSystem;
   }
 
   Future<List<Fix>> compute() async {
-    // If the source was changed between the constructor and running
-    // this asynchronous method, it is not safe to use the unit.
-    if (_modificationStamp(unitSource.fullName) != fileStamp) {
-      return const <Fix>[];
-    }
-
     try {
       utils = new CorrectionUtils(unit);
     } catch (e) {
       throw new CancelCorrectionException(exception: e);
     }
 
     errorOffset = error.offset;
     errorLength = error.length;
     errorEnd = errorOffset + errorLength;
     errorRange = new SourceRange(errorOffset, errorLength);
@@ skipping 256 matching lines @@
   }
 
   /**
    * Returns `true` if the `async` proposal was added.
    */
   Future<Null> _addFix_addAsync() async {
     FunctionBody body = node.getAncestor((n) => n is FunctionBody);
     if (body != null && body.keyword == null) {
       TypeProvider typeProvider = await this.typeProvider;
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.convertFunctionFromSyncToAsync(body, typeProvider);
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.ADD_ASYNC);
     }
   }
 
   Future<Null> _addFix_addMissingMethodCall() async {
     ClassDeclaration targetClass = node.parent as ClassDeclaration;
     int insertOffset = targetClass.end - 1;
     // prepare environment
     String prefix = utils.getIndent(1);
     String prefix2 = utils.getIndent(2);
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addInsertion(insertOffset, (DartEditBuilder builder) {
         builder.selectHere();
         builder.write(prefix);
         builder.write('call() {');
         // TO-DO
         builder.write(eol);
         builder.write(prefix2);
         builder.write('// TODO: implement call');
         builder.write(eol);
         // close method
@@ skipping 52 matching lines @@
               return;
             }
             targetOffset = paren.end;
           } else {
             return;
           }
         }
         Source targetSource = targetElement.source;
         String targetFile = targetSource.fullName;
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder
-            .addFileEdit(targetFile, targetSource.modificationStamp,
-                (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(targetFile,
+            (DartFileEditBuilder builder) {
           builder.addInsertion(targetOffset, (DartEditBuilder builder) {
             if (numRequired != 0) {
               builder.write(', ');
             }
             builder.writeParameterMatchingArgument(
                 argument, numRequired, new Set<String>());
             if (numRequired != numParameters) {
               builder.write(', ');
             }
           });
         });
         _addFixFromBuilder(
             changeBuilder, DartFixKind.ADD_MISSING_PARAMETER_REQUIRED);
         if (optionalParameters.isEmpty) {
           DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-          await changeBuilder
-              .addFileEdit(targetFile, targetSource.modificationStamp,
-                  (DartFileEditBuilder builder) {
+          await changeBuilder.addFileEdit(targetFile,
+              (DartFileEditBuilder builder) {
             builder.addInsertion(targetOffset, (DartEditBuilder builder) {
               if (numRequired != 0) {
                 builder.write(', ');
               }
               builder.write('[');
               builder.writeParameterMatchingArgument(
                   argument, numRequired, new Set<String>());
               builder.write(']');
             });
           });
@@ skipping 29 matching lines @@
       if (parts.length < 2) {
         return;
       }
 
       // add proposal
       String paramName = parts[1];
       final List<Expression> args = argumentList.arguments;
       int offset =
           args.isEmpty ? argumentList.leftParenthesis.end : args.last.end;
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addInsertion(offset, (DartEditBuilder builder) {
           if (args.isNotEmpty) {
             builder.write(', ');
           }
           List<ParameterElement> parameters =
               (targetElement as ExecutableElement).parameters;
           ParameterElement element = parameters
               .firstWhere((p) => p.name == paramName, orElse: () => null);
           String defaultValue = getDefaultStringParameterValue(element);
           builder.write('$paramName: $defaultValue');
@@ skipping 20 matching lines @@
 
     // Handle doc comments.
     Token token = member.beginToken;
     if (token is CommentToken) {
       token = (token as CommentToken).parent;
     }
 
     Position exitPosition = new Position(file, token.offset - 1);
     String indent = utils.getIndent(1);
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addSimpleReplacement(
           range.startLength(token, 0), '@override$eol$indent');
     });
     changeBuilder.setSelection(exitPosition);
     _addFixFromBuilder(changeBuilder, DartFixKind.LINT_ADD_OVERRIDE);
   }
 
   Future<Null> _addFix_boolInsteadOfBoolean() async {
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addSimpleReplacement(range.error(error), 'bool');
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.REPLACE_BOOLEAN_WITH_BOOL);
   }
 
   Future<Null> _addFix_canBeNullAfterNullAware() async {
     AstNode node = coveredNode;
     if (node is Expression) {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         AstNode parent = node.parent;
         while (parent != null) {
           if (parent is MethodInvocation && parent.target == node) {
             builder.addSimpleReplacement(range.token(parent.operator), '?.');
           } else if (parent is PropertyAccess && parent.target == node) {
             builder.addSimpleReplacement(range.token(parent.operator), '?.');
           } else {
             break;
           }
           node = parent;
@@ skipping 10 matching lines @@
         declaration.initializer == coveredNode) {
       AstNode variableList = declaration.parent;
       if (variableList is VariableDeclarationList &&
           variableList.variables.length == 1) {
         TypeAnnotation typeNode = variableList.type;
         if (typeNode != null) {
           Expression initializer = coveredNode;
           DartType newType = initializer.bestType;
           if (newType is InterfaceType || newType is FunctionType) {
             DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-            await changeBuilder.addFileEdit(file, fileStamp,
+            await changeBuilder.addFileEdit(file,
                 (DartFileEditBuilder builder) {
               builder.addReplacement(range.node(typeNode),
                   (DartEditBuilder builder) {
                 builder.writeType(newType);
               });
             });
             _addFixFromBuilder(
                 changeBuilder, DartFixKind.CHANGE_TYPE_ANNOTATION, args: [
               resolutionMap.typeForTypeName(typeNode),
               newType.displayName
             ]);
           }
         }
       }
     }
   }
 
   Future<Null> _addFix_convertFlutterChild() async {
     NamedExpression namedExp = findFlutterNamedExpression(node, 'child');
     if (namedExp == null) {
       return;
     }
     InstanceCreationExpression childArg = getChildWidget(namedExp, false);
     if (childArg != null) {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         convertFlutterChildToChildren2(
             builder,
             childArg,
             namedExp,
             eol,
             utils.getNodeText,
             utils.getLinePrefix,
             utils.getIndent,
             utils.getText,
             range.node);
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.CONVERT_FLUTTER_CHILD);
       return;
     }
     ListLiteral listArg = getChildList(namedExp);
     if (listArg != null) {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addSimpleInsertion(namedExp.offset + 'child'.length, 'ren');
         if (listArg.typeArguments == null) {
           builder.addSimpleInsertion(listArg.offset, '<Widget>');
         }
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.CONVERT_FLUTTER_CHILD);
     }
   }
 
   Future<Null> _addFix_convertFlutterChildren() async {
@@ skipping 24 matching lines @@
       }
     } else {
       return;
     }
     // prepare environment
     Element targetUnit;
     String prefix = '';
     String suffix = '';
     int offset = -1;
     String filePath;
-    int modificationTime = 0;
     if (prefixElement == null) {
       targetUnit = unitElement;
       CompilationUnitMember enclosingMember =
           node.getAncestor((node) => node.parent is CompilationUnit);
       if (enclosingMember == null) {
         return;
       }
       offset = enclosingMember.end;
       filePath = file;
-      modificationTime = fileStamp;
       prefix = '$eol$eol';
     } else {
       for (ImportElement import in unitLibraryElement.imports) {
         if (prefixElement is PrefixElement && import.prefix == prefixElement) {
           LibraryElement library = import.importedLibrary;
           if (library != null) {
             targetUnit = library.definingCompilationUnit;
             Source targetSource = targetUnit.source;
             offset = targetSource.contents.data.length;
             filePath = targetSource.fullName;
-            modificationTime = targetSource.modificationStamp;
             prefix = '$eol';
             suffix = '$eol';
             break;
           }
         }
       }
     }
     if (offset < 0) {
       return;
     }
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(filePath, modificationTime,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(filePath, (DartFileEditBuilder builder) {
       builder.addInsertion(offset, (DartEditBuilder builder) {
         builder.write(prefix);
         builder.writeClassDeclaration(name, nameGroupName: 'NAME');
         builder.write(suffix);
       });
       if (prefixElement == null) {
         builder.addLinkedPosition(range.node(node), 'NAME');
       }
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.CREATE_CLASS, args: [name]);
@@ skipping 21 matching lines @@
           fieldNames.addAll(variableList.variables
               .where((v) => v.initializer == null)
               .map((v) => v.name.name));
         }
       }
     }
     // prepare location for a new constructor
     ClassMemberLocation targetLocation =
         utils.prepareNewConstructorLocation(classDeclaration);
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addInsertion(targetLocation.offset, (DartEditBuilder builder) {
         builder.write(targetLocation.prefix);
         builder.writeConstructorDeclaration(classDeclaration.name.name,
             fieldNames: fieldNames);
         builder.write(targetLocation.suffix);
       });
     });
     _addFixFromBuilder(
         changeBuilder, DartFixKind.CREATE_CONSTRUCTOR_FOR_FINAL_FIELDS);
   }
@@ skipping 22 matching lines @@
     // prepare location for a new constructor
     AstNode targetTypeNode = getParsedClassElementNode(targetElement);
     if (targetTypeNode is! ClassDeclaration) {
       return;
     }
     ClassMemberLocation targetLocation =
         utils.prepareNewConstructorLocation(targetTypeNode);
     Source targetSource = targetElement.source;
     String targetFile = targetSource.fullName;
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(targetFile, targetSource.modificationStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(targetFile, (DartFileEditBuilder builder) {
       builder.addInsertion(targetLocation.offset, (DartEditBuilder builder) {
         builder.write(targetLocation.prefix);
         builder.writeConstructorDeclaration(targetElement.name,
             argumentList: instanceCreation.argumentList);
         builder.write(targetLocation.suffix);
       });
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.CREATE_CONSTRUCTOR,
         args: [constructorName]);
   }
@@ skipping 32 matching lines @@
     // prepare location for a new constructor
     ClassElement targetElement = targetType.element as ClassElement;
     AstNode targetTypeNode = getParsedClassElementNode(targetElement);
     if (targetTypeNode is! ClassDeclaration) {
       return;
     }
     ClassMemberLocation targetLocation =
         utils.prepareNewConstructorLocation(targetTypeNode);
     String targetFile = targetElement.source.fullName;
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addInsertion(targetLocation.offset, (DartEditBuilder builder) {
         builder.write(targetLocation.prefix);
         builder.writeConstructorDeclaration(targetElement.name,
             argumentList: instanceCreation.argumentList,
             constructorName: name,
             constructorNameGroupName: 'NAME');
         builder.write(targetLocation.suffix);
       });
       if (targetFile == file) {
         builder.addLinkedPosition(range.node(name), 'NAME');
@@ skipping 29 matching lines @@
         insertOffset = targetConstructor.parameters.end;
         prefix = ' : ';
       } else {
         ConstructorInitializer lastInitializer =
             initializers[initializers.length - 1];
         insertOffset = lastInitializer.end;
         prefix = ', ';
       }
       String proposalName = _getConstructorProposalName(superConstructor);
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addInsertion(insertOffset, (DartEditBuilder builder) {
           builder.write(prefix);
           // add super constructor name
           builder.write('super');
           if (!isEmpty(constructorName)) {
             builder.write('.');
             builder.addSimpleLinkedEdit('NAME', constructorName);
           }
           // add arguments
           builder.write('(');
@@ skipping 37 matching lines @@
       }
       // prepare parameters and arguments
       Iterable<ParameterElement> requiredParameters =
           superConstructor.parameters.where(
               (parameter) => parameter.parameterKind == ParameterKind.REQUIRED);
       // add proposal
       ClassMemberLocation targetLocation =
           utils.prepareNewConstructorLocation(targetClassNode);
       String proposalName = _getConstructorProposalName(superConstructor);
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addInsertion(targetLocation.offset, (DartEditBuilder builder) {
           void writeParameters(bool includeType) {
             bool firstParameter = true;
             for (ParameterElement parameter in requiredParameters) {
               if (firstParameter) {
                 firstParameter = false;
               } else {
                 builder.write(', ');
               }
               String parameterName = parameter.displayName;
@@ skipping 83 matching lines @@
       return;
     }
     ClassDeclaration targetClassNode = targetTypeNode;
     // prepare location
     ClassMemberLocation targetLocation =
         utils.prepareNewFieldLocation(targetClassNode);
     // build field source
     Source targetSource = targetClassElement.source;
     String targetFile = targetSource.fullName;
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(targetFile, targetSource.modificationStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(targetFile, (DartFileEditBuilder builder) {
       Expression fieldTypeNode = climbPropertyAccess(nameNode);
       DartType fieldType = _inferUndefinedExpressionType(fieldTypeNode);
       builder.addInsertion(targetLocation.offset, (DartEditBuilder builder) {
         builder.write(targetLocation.prefix);
         builder.writeFieldDeclaration(name,
             isStatic: staticModifier,
             nameGroupName: 'NAME',
             type: fieldType,
             typeGroupName: 'TYPE');
         builder.write(targetLocation.suffix);
@@ skipping 17 matching lines @@
       return;
     }
     SimpleIdentifier nameNode = parameter.identifier;
     String name = nameNode.name;
     ClassMemberLocation targetLocation =
         utils.prepareNewFieldLocation(targetClassNode);
     //
     // Add proposal.
     //
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       DartType fieldType = parameter.type?.type;
       builder.addInsertion(targetLocation.offset, (DartEditBuilder builder) {
         builder.write(targetLocation.prefix);
         builder.writeFieldDeclaration(name,
             nameGroupName: 'NAME', type: fieldType, typeGroupName: 'TYPE');
         builder.write(targetLocation.suffix);
       });
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.CREATE_FIELD, args: [name]);
   }
@@ skipping 98 matching lines @@
       return;
     }
     ClassDeclaration targetClassNode = targetTypeNode;
     // prepare location
     ClassMemberLocation targetLocation =
         utils.prepareNewGetterLocation(targetClassNode);
     // build method source
     Source targetSource = targetClassElement.source;
     String targetFile = targetSource.fullName;
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(targetFile, targetSource.modificationStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(targetFile, (DartFileEditBuilder builder) {
       builder.addInsertion(targetLocation.offset, (DartEditBuilder builder) {
         Expression fieldTypeNode = climbPropertyAccess(nameNode);
         DartType fieldType = _inferUndefinedExpressionType(fieldTypeNode);
         builder.write(targetLocation.prefix);
         builder.writeGetterDeclaration(name,
             isStatic: staticModifier,
             nameGroupName: 'NAME',
             returnType: fieldType,
             returnTypeGroupName: 'TYPE');
         builder.write(targetLocation.suffix);
       });
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.CREATE_GETTER, args: [name]);
   }
 
   Future<Null> _addFix_createImportUri() async {
     // TODO(brianwilkerson) Generalize this to allow other valid string literals.
     // TODO(brianwilkerson) Support the case where the node's parent is a Configuration.
     if (node is SimpleStringLiteral && node.parent is ImportDirective) {
       ImportDirective importDirective = node.parent;
       Source source = importDirective.uriSource;
       if (source != null) {
         String file = source.fullName;
         if (isAbsolute(file) && AnalysisEngine.isDartFileName(file)) {
           String libName = _computeLibraryName(file);
           DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-          await changeBuilder.addFileEdit(source.fullName, -1,
+          await changeBuilder.addFileEdit(source.fullName,
               (DartFileEditBuilder builder) {
             builder.addSimpleInsertion(0, 'library $libName;$eol$eol');
           });
           _addFixFromBuilder(changeBuilder, DartFixKind.CREATE_FILE,
               args: [source.shortName]);
         }
       }
     }
   }
 
   Future<Null> _addFix_createLocalVariable() async {
     if (node is! SimpleIdentifier) {
       return;
     }
     SimpleIdentifier nameNode = node;
     String name = nameNode.name;
     // if variable is assigned, convert assignment into declaration
     if (node.parent is AssignmentExpression) {
       AssignmentExpression assignment = node.parent;
       if (assignment.leftHandSide == node &&
           assignment.operator.type == TokenType.EQ &&
           assignment.parent is ExpressionStatement) {
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder.addSimpleInsertion(node.offset, 'var ');
         });
         _addFixFromBuilder(changeBuilder, DartFixKind.CREATE_LOCAL_VARIABLE,
             args: [name]);
         return;
       }
     }
     // prepare target Statement
     Statement target = node.getAncestor((x) => x is Statement);
     if (target == null) {
       return;
     }
     String prefix = utils.getNodePrefix(target);
     // compute type
     DartType type = _inferUndefinedExpressionType(node);
     if (!(type == null ||
         type is InterfaceType ||
         type is FunctionType &&
             type.element != null &&
             !type.element.isSynthetic)) {
       return;
     }
     // build variable declaration source
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addInsertion(target.offset, (DartEditBuilder builder) {
         builder.writeLocalVariableDeclaration(name,
             nameGroupName: 'NAME', type: type, typeGroupName: 'TYPE');
         builder.write(eol);
         builder.write(prefix);
       });
       builder.addLinkedPosition(range.node(node), 'NAME');
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.CREATE_LOCAL_VARIABLE,
         args: [name]);
@@ skipping 20 matching lines @@
       }
       if (a.kind == ElementKind.GETTER) {
         return -1;
       }
       return 1;
     });
     int numElements = elements.length;
     int insertOffset = targetClass.end - 1;
     String prefix = utils.getIndent(1);
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addInsertion(insertOffset, (DartEditBuilder builder) {
         // TODO(brianwilkerson) Compare with builder.writeOverrideOfInheritedMember
         // The builder method doesn't merge getter/setter pairs into fields.
         // EOL management
         bool isFirst = true;
         void addEolIfNotFirst() {
           if (!isFirst || utils.isClassWithEmptyBody(targetClass)) {
             builder.write(eol);
           }
           isFirst = false;
@@ skipping 98 matching lines @@
     builder.write(eol);
     utils.targetExecutableElement = null;
   }
 
   Future<Null> _addFix_createNoSuchMethod() async {
     ClassDeclaration targetClass = node.parent as ClassDeclaration;
     // prepare environment
     String prefix = utils.getIndent(1);
     int insertOffset = targetClass.end - 1;
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addInsertion(insertOffset, (DartEditBuilder builder) {
         builder.selectHere();
         // insert empty line before existing member
         if (!targetClass.members.isEmpty) {
           builder.write(eol);
         }
         // append method
         builder.write(prefix);
         builder.write(
             'noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);');
         builder.write(eol);
       });
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.CREATE_NO_SUCH_METHOD);
   }
 
   Future<Null> _addFix_createPartUri() async {
     // TODO(brianwilkerson) Generalize this to allow other valid string literals.
     if (node is SimpleStringLiteral && node.parent is PartDirective) {
       PartDirective partDirective = node.parent;
       Source source = partDirective.uriSource;
       if (source != null) {
         String libName = unitLibraryElement.name;
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(source.fullName, -1,
+        await changeBuilder.addFileEdit(source.fullName,
             (DartFileEditBuilder builder) {
           // TODO(brianwilkerson) Consider using the URI rather than name
           builder.addSimpleInsertion(0, 'part of $libName;$eol$eol');
         });
         _addFixFromBuilder(changeBuilder, DartFixKind.CREATE_FILE,
             args: [source.shortName]);
       }
     }
   }
 
   Future<Null> _addFix_illegalAsyncReturnType() async {
     // prepare the existing type
     TypeAnnotation typeName = node.getAncestor((n) => n is TypeAnnotation);
     TypeProvider typeProvider = this.typeProvider;
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.replaceTypeWithFuture(typeName, typeProvider);
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.REPLACE_RETURN_TYPE_FUTURE);
   }
 
   Future<Null> _addFix_importLibrary(FixKind kind, Source library) async {
     String libraryUri = getLibrarySourceUri(unitLibraryElement, library);
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.importLibraries([library]);
     });
     _addFixFromBuilder(changeBuilder, kind, args: [libraryUri]);
   }
 
   Future<Null> _addFix_importLibrary_withElement(String name,
       List<ElementKind> elementKinds, TopLevelDeclarationKind kind2) async {
     // ignore if private
     if (name.startsWith('_')) {
       return;
@@ skipping 11 matching lines @@
       if (element is PropertyAccessorElement) {
         element = (element as PropertyAccessorElement).variable;
       }
       if (!elementKinds.contains(element.kind)) {
         continue;
       }
       // may be apply prefix
       PrefixElement prefix = imp.prefix;
       if (prefix != null) {
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder.addSimpleReplacement(
               range.startLength(node, 0), '${prefix.displayName}.');
         });
         _addFixFromBuilder(changeBuilder, DartFixKind.IMPORT_LIBRARY_PREFIX,
             args: [libraryElement.displayName, prefix.displayName]);
         continue;
       }
       // may be update "show" directive
       List<NamespaceCombinator> combinators = imp.combinators;
       if (combinators.length == 1 && combinators[0] is ShowElementCombinator) {
         ShowElementCombinator showCombinator =
             combinators[0] as ShowElementCombinator;
         // prepare new set of names to show
         Set<String> showNames = new SplayTreeSet<String>();
         showNames.addAll(showCombinator.shownNames);
         showNames.add(name);
         // prepare library name - unit name or 'dart:name' for SDK library
         String libraryName = libraryElement.definingCompilationUnit.displayName;
         if (libraryElement.isInSdk) {
           libraryName = imp.uri;
         }
         // don't add this library again
         alreadyImportedWithPrefix.add(libraryElement.source);
         // update library
         String newShowCode = 'show ${showNames.join(', ')}';
         int offset = showCombinator.offset;
         int length = showCombinator.end - offset;
         String libraryFile = unitLibraryElement.source.fullName;
-        int libraryStamp = unitLibraryElement.context
-            .getModificationStamp(unitLibraryElement.source);
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(libraryFile, libraryStamp,
+        await changeBuilder.addFileEdit(libraryFile,
             (DartFileEditBuilder builder) {
           builder.addSimpleReplacement(
               new SourceRange(offset, length), newShowCode);
         });
         _addFixFromBuilder(changeBuilder, DartFixKind.IMPORT_LIBRARY_SHOW,
             args: [libraryName]);
       }
     }
     // Find new top-level declarations.
     {
@@ skipping 63 matching lines @@
     }
   }
 
   Future<Null> _addFix_insertSemicolon() async {
     if (error.message.contains("';'")) {
       if (_isAwaitNode()) {
         return;
       }
       int insertOffset = error.offset + error.length;
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addSimpleInsertion(insertOffset, ';');
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.INSERT_SEMICOLON);
     }
   }
 
   Future<Null> _addFix_isNotNull() async {
     if (coveredNode is IsExpression) {
       IsExpression isExpression = coveredNode as IsExpression;
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder
             .addReplacement(range.endEnd(isExpression.expression, isExpression),
                 (DartEditBuilder builder) {
           builder.write(' != null');
         });
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.USE_NOT_EQ_NULL);
     }
   }
 
   Future<Null> _addFix_isNull() async {
     if (coveredNode is IsExpression) {
       IsExpression isExpression = coveredNode as IsExpression;
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder
             .addReplacement(range.endEnd(isExpression.expression, isExpression),
                 (DartEditBuilder builder) {
           builder.write(' == null');
         });
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.USE_EQ_EQ_NULL);
     }
   }
 
   Future<Null> _addFix_makeEnclosingClassAbstract() async {
     ClassDeclaration enclosingClass =
         node.getAncestor((node) => node is ClassDeclaration);
     if (enclosingClass == null) {
       return;
     }
     String className = enclosingClass.name.name;
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addSimpleInsertion(
           enclosingClass.classKeyword.offset, 'abstract ');
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.MAKE_CLASS_ABSTRACT,
         args: [className]);
   }
 
   Future<Null> _addFix_makeFieldNotFinal() async {
     AstNode node = this.node;
     if (node is SimpleIdentifier &&
         node.bestElement is PropertyAccessorElement) {
       PropertyAccessorElement getter = node.bestElement;
       if (getter.isGetter &&
           getter.isSynthetic &&
           !getter.variable.isSynthetic &&
           getter.variable.setter == null &&
           getter.enclosingElement is ClassElement) {
         AstNode name =
             await astProvider.getParsedNameForElement(getter.variable);
         AstNode variable = name?.parent;
         if (variable is VariableDeclaration &&
             variable.parent is VariableDeclarationList &&
             variable.parent.parent is FieldDeclaration) {
           VariableDeclarationList declarationList = variable.parent;
           Token keywordToken = declarationList.keyword;
           if (declarationList.variables.length == 1 &&
               keywordToken.keyword == Keyword.FINAL) {
             DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-            await changeBuilder.addFileEdit(file, fileStamp,
+            await changeBuilder.addFileEdit(file,
                 (DartFileEditBuilder builder) {
               if (declarationList.type != null) {
                 builder.addReplacement(
                     range.startStart(keywordToken, declarationList.type),
                     (DartEditBuilder builder) {});
               } else {
                 builder.addReplacement(range.startStart(keywordToken, variable),
                     (DartEditBuilder builder) {
                   builder.write('var ');
                 });
               }
             });
             String fieldName = getter.variable.displayName;
             _addFixFromBuilder(changeBuilder, DartFixKind.MAKE_FIELD_NOT_FINAL,
                 args: [fieldName]);
           }
         }
       }
     }
   }
 
   Future<Null> _addFix_nonBoolCondition_addNotNull() async {
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addSimpleInsertion(error.offset + error.length, ' != null');
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.ADD_NE_NULL);
   }
 
   Future<Null> _addFix_removeAwait() async {
     final awaitExpression = node;
     if (awaitExpression is AwaitExpression) {
       final awaitToken = awaitExpression.awaitKeyword;
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addDeletion(range.startStart(awaitToken, awaitToken.next));
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_AWAIT);
     }
   }
 
   Future<Null> _addFix_removeDeadCode() async {
     AstNode coveringNode = this.coveredNode;
     if (coveringNode is Expression) {
       AstNode parent = coveredNode.parent;
       if (parent is BinaryExpression) {
         if (parent.rightOperand == coveredNode) {
           DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-          await changeBuilder.addFileEdit(file, fileStamp,
-              (DartFileEditBuilder builder) {
+          await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
             builder.addDeletion(range.endEnd(parent.leftOperand, coveredNode));
           });
           _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_DEAD_CODE);
         }
       }
     } else if (coveringNode is Block) {
       Block block = coveringNode;
       List<Statement> statementsToRemove = <Statement>[];
       for (Statement statement in block.statements) {
         if (range.node(statement).intersects(errorRange)) {
           statementsToRemove.add(statement);
         }
       }
       if (statementsToRemove.isNotEmpty) {
         SourceRange rangeToRemove =
             utils.getLinesRangeStatements(statementsToRemove);
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder.addDeletion(rangeToRemove);
         });
         _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_DEAD_CODE);
       }
     } else if (coveringNode is Statement) {
       SourceRange rangeToRemove =
           utils.getLinesRangeStatements(<Statement>[coveringNode]);
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addDeletion(rangeToRemove);
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_DEAD_CODE);
     }
   }
 
   Future<Null> _addFix_removeEmptyStatement() async {
     EmptyStatement emptyStatement = node;
     if (emptyStatement.parent is Block) {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addDeletion(utils.getLinesRange(range.node(emptyStatement)));
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_EMPTY_STATEMENT);
     } else {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addSimpleReplacement(
             range.endEnd(emptyStatement.beginToken.previous, emptyStatement),
             ' {}');
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.REPLACE_WITH_BRACKETS);
     }
   }
 
   Future<Null> _addFix_removeInitializer() async {
     // Retrieve the linted node.
     VariableDeclaration ancestor =
         node.getAncestor((a) => a is VariableDeclaration);
     if (ancestor == null) {
       return;
     }
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addDeletion(range.endEnd(ancestor.name, ancestor.initializer));
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_INITIALIZER);
   }
 
   Future<Null> _addFix_removeInterpolationBraces() async {
     AstNode node = this.node;
     if (node is InterpolationExpression) {
       Token right = node.rightBracket;
       if (node.expression != null && right != null) {
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder.addSimpleReplacement(
               range.startStart(node, node.expression), r'$');
           builder.addDeletion(range.token(right));
         });
         _addFixFromBuilder(
             changeBuilder, DartFixKind.LINT_REMOVE_INTERPOLATION_BRACES);
       } else {}
     }
   }
 
   Future<Null> _addFix_removeMethodDeclaration() async {
     MethodDeclaration declaration =
         node.getAncestor((node) => node is MethodDeclaration);
     if (declaration != null) {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addDeletion(utils.getLinesRange(range.node(declaration)));
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_METHOD_DECLARATION);
     }
   }
 
   Future<Null> _addFix_removeParameters_inGetterDeclaration() async {
     if (node is MethodDeclaration) {
       MethodDeclaration method = node as MethodDeclaration;
       SimpleIdentifier name = method.name;
       FunctionBody body = method.body;
       if (name != null && body != null) {
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder.addSimpleReplacement(range.endStart(name, body), ' ');
         });
         _addFixFromBuilder(
             changeBuilder, DartFixKind.REMOVE_PARAMETERS_IN_GETTER_DECLARATION);
       }
     }
   }
 
   Future<Null> _addFix_removeParentheses_inGetterInvocation() async {
     if (node is SimpleIdentifier && node.parent is MethodInvocation) {
       MethodInvocation invocation = node.parent as MethodInvocation;
       if (invocation.methodName == node && invocation.target != null) {
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder.addDeletion(range.endEnd(node, invocation));
         });
         _addFixFromBuilder(
             changeBuilder, DartFixKind.REMOVE_PARENTHESIS_IN_GETTER_INVOCATION);
       }
     }
   }
 
   Future<Null> _addFix_removeThisExpression() async {
     final thisExpression = node is ThisExpression
         ? node
         : node.getAncestor((node) => node is ThisExpression);
     final parent = thisExpression.parent;
     if (parent is PropertyAccess) {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addDeletion(range.startEnd(parent, parent.operator));
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_THIS_EXPRESSION);
     } else if (parent is MethodInvocation) {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addDeletion(range.startEnd(parent, parent.operator));
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_THIS_EXPRESSION);
     }
   }
 
   Future<Null> _addFix_removeTypeName() async {
     final TypeName type = node.getAncestor((node) => node is TypeName);
     if (type != null) {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addDeletion(range.startStart(type, type.endToken.next));
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_TYPE_NAME);
     }
   }
 
   Future<Null> _addFix_removeUnnecessaryCast() async {
     if (coveredNode is! AsExpression) {
       return;
     }
     AsExpression asExpression = coveredNode as AsExpression;
     Expression expression = asExpression.expression;
     int expressionPrecedence = getExpressionPrecedence(expression);
     // remove 'as T' from 'e as T'
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addDeletion(range.endEnd(expression, asExpression));
       _removeEnclosingParentheses(builder, asExpression, expressionPrecedence);
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_UNNECESSARY_CAST);
   }
 
   Future<Null> _addFix_removeUnusedCatchClause() async {
     if (node is SimpleIdentifier) {
       AstNode catchClause = node.parent;
       if (catchClause is CatchClause &&
           catchClause.exceptionParameter == node) {
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder.addDeletion(
               range.startStart(catchClause.catchKeyword, catchClause.body));
         });
         _addFixFromBuilder(
             changeBuilder, DartFixKind.REMOVE_UNUSED_CATCH_CLAUSE);
       }
     }
   }
 
   Future<Null> _addFix_removeUnusedCatchStack() async {
     if (node is SimpleIdentifier) {
       AstNode catchClause = node.parent;
       if (catchClause is CatchClause &&
           catchClause.stackTraceParameter == node &&
           catchClause.exceptionParameter != null) {
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder
               .addDeletion(range.endEnd(catchClause.exceptionParameter, node));
         });
         _addFixFromBuilder(
             changeBuilder, DartFixKind.REMOVE_UNUSED_CATCH_STACK);
       }
     }
   }
 
   Future<Null> _addFix_removeUnusedImport() async {
     // prepare ImportDirective
     ImportDirective importDirective =
         node.getAncestor((node) => node is ImportDirective);
     if (importDirective == null) {
       return;
     }
     // remove the whole line with import
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addDeletion(utils.getLinesRange(range.node(importDirective)));
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.REMOVE_UNUSED_IMPORT);
   }
 
   Future<Null> _addFix_replaceVarWithDynamic() async {
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addSimpleReplacement(range.error(error), 'dynamic');
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.REPLACE_VAR_WITH_DYNAMIC);
   }
 
   Future<Null> _addFix_replaceWithConditionalAssignment() async {
     IfStatement ifStatement = node is IfStatement
         ? node
         : node.getAncestor((node) => node is IfStatement);
     var thenStatement = ifStatement.thenStatement;
     Statement uniqueStatement(Statement statement) {
       if (statement is Block) {
         return uniqueStatement(statement.statements.first);
       }
       return statement;
     }
 
     thenStatement = uniqueStatement(thenStatement);
     if (thenStatement is ExpressionStatement) {
       final expression = thenStatement.expression.unParenthesized;
       if (expression is AssignmentExpression) {
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder.addReplacement(range.node(ifStatement),
               (DartEditBuilder builder) {
             builder.write(utils.getNodeText(expression.leftHandSide));
             builder.write(' ??= ');
             builder.write(utils.getNodeText(expression.rightHandSide));
             builder.write(';');
           });
         });
         _addFixFromBuilder(
             changeBuilder, DartFixKind.REPLACE_WITH_CONDITIONAL_ASSIGNMENT);
       }
     }
   }
 
   Future<Null> _addFix_replaceWithConstInstanceCreation() async {
     if (coveredNode is InstanceCreationExpression) {
       var instanceCreation = coveredNode as InstanceCreationExpression;
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addSimpleReplacement(
             range.token(instanceCreation.keyword), 'const');
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.USE_CONST);
     }
   }
 
   Future<Null> _addFix_replaceWithIdentifier() async {
     final FunctionTypedFormalParameter functionTyped =
         node.getAncestor((node) => node is FunctionTypedFormalParameter);
     if (functionTyped != null) {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addSimpleReplacement(range.node(functionTyped),
             utils.getNodeText(functionTyped.identifier));
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.REPLACE_WITH_IDENTIFIER);
     } else {
       await _addFix_removeTypeName();
     }
   }
 
   Future<Null> _addFix_replaceWithLiteral() async {
     final InstanceCreationExpression instanceCreation =
         node.getAncestor((node) => node is InstanceCreationExpression);
     final InterfaceType type = instanceCreation.staticType;
     final generics = instanceCreation.constructorName.type.typeArguments;
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addReplacement(range.node(instanceCreation),
           (DartEditBuilder builder) {
         if (generics != null) {
           builder.write(utils.getNodeText(generics));
         }
         if (type.name == 'List') {
           builder.write('[]');
         } else {
           builder.write('{}');
         }
       });
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.REPLACE_WITH_LITERAL);
   }
 
   Future<Null> _addFix_replaceWithTearOff() async {
     FunctionExpression ancestor =
         node.getAncestor((a) => a is FunctionExpression);
     if (ancestor == null) {
       return;
     }
     Future<Null> addFixOfExpression(InvocationExpression expression) async {
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         builder.addReplacement(range.node(ancestor), (DartEditBuilder builder) {
           if (expression is MethodInvocation && expression.target != null) {
             builder.write(utils.getNodeText(expression.target));
             builder.write('.');
           }
           builder.write(utils.getNodeText(expression.function));
         });
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.REPLACE_WITH_TEAR_OFF);
     }
@@ skipping 46 matching lines @@
         if (importElement.prefix?.name == prefixName) {
           Map<String, Element> namespace = getImportNamespace(importElement);
           finder._updateList(namespace.values);
         }
       }
       // If we have a close enough element, suggest to use it.
       if (finder._element != null) {
         String closestName = finder._element.name;
         if (closestName != null) {
           DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-          await changeBuilder.addFileEdit(file, fileStamp,
-              (DartFileEditBuilder builder) {
+          await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
             builder.addSimpleReplacement(range.node(node), closestName);
           });
           _addFixFromBuilder(changeBuilder, DartFixKind.CHANGE_TO,
               args: [closestName]);
         }
       }
     }
   }
 
   Future<Null> _addFix_undefinedClassAccessor_useSimilar() async {
@@ skipping 42 matching lines @@
         DartType type = target.bestType;
         if (type is InterfaceType) {
           ClassElement classElement = type.element;
           _updateFinderWithClassMembers(finder, classElement);
         }
       }
       // if we have close enough element, suggest to use it
       if (finder._element != null) {
         String closestName = finder._element.name;
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder.addSimpleReplacement(range.node(node), closestName);
         });
         _addFixFromBuilder(changeBuilder, DartFixKind.CHANGE_TO,
             args: [closestName]);
       }
     }
   }
 
   Future<Null> _addFix_undefinedFunction_create() async {
     // should be the name of the invocation
@@ skipping 10 matching lines @@
     // prepare environment
     int insertOffset;
     String sourcePrefix;
     AstNode enclosingMember =
         node.getAncestor((node) => node is CompilationUnitMember);
     insertOffset = enclosingMember.end;
     sourcePrefix = '$eol$eol';
     utils.targetClassElement = null;
     // build method source
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       builder.addInsertion(insertOffset, (DartEditBuilder builder) {
         builder.write(sourcePrefix);
         // append return type
         {
           DartType type = _inferUndefinedExpressionType(invocation);
           if (builder.writeType(type, groupName: 'RETURN_TYPE')) {
             builder.write(' ');
           }
         }
         // append name
@@ skipping 40 matching lines @@
       for (ImportElement importElement in unitLibraryElement.imports) {
         if (importElement.prefix?.name == prefixName) {
           Map<String, Element> namespace = getImportNamespace(importElement);
           finder._updateList(namespace.values);
         }
       }
       // If we have a close enough element, suggest to use it.
       if (finder._element != null) {
         String closestName = finder._element.name;
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           builder.addSimpleReplacement(range.node(node), closestName);
         });
         _addFixFromBuilder(changeBuilder, DartFixKind.CHANGE_TO,
             args: [closestName]);
       }
     }
   }
 
   Future<Null> _addFix_undefinedMethod_create() async {
     if (node is SimpleIdentifier && node.parent is MethodInvocation) {
@@ skipping 37 matching lines @@
         }
         // use different utils
         CompilationUnitElement targetUnitElement =
             getCompilationUnitElement(targetClassElement);
         CompilationUnit targetUnit = getParsedUnit(targetUnitElement);
         utils = new CorrectionUtils(targetUnit);
       }
       ClassMemberLocation targetLocation =
           utils.prepareNewMethodLocation(targetClassNode);
       String targetFile = targetElement.source.fullName;
-      int targetStamp =
-          targetElement.context.getModificationStamp(targetElement.source);
       // build method source
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(targetFile, targetStamp,
+      await changeBuilder.addFileEdit(targetFile,
           (DartFileEditBuilder builder) {
         builder.addInsertion(targetLocation.offset, (DartEditBuilder builder) {
           builder.write(targetLocation.prefix);
           // maybe "static"
           if (staticModifier) {
             builder.write('static ');
           }
           // append return type
           {
             DartType type = _inferUndefinedExpressionType(invocation);
@@ skipping 45 matching lines @@
         fields.map((field) => 'this.${field.name}').join(', ');
     // prepare the last required parameter
     FormalParameter lastRequiredParameter;
     List<FormalParameter> parameters = constructor.parameters.parameters;
     for (FormalParameter parameter in parameters) {
       if (parameter.kind == ParameterKind.REQUIRED) {
         lastRequiredParameter = parameter;
       }
     }
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(file, fileStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
       // append new field formal initializers
       if (lastRequiredParameter != null) {
         builder.addSimpleInsertion(
             lastRequiredParameter.end, ', $fieldParametersCode');
       } else {
         int offset = constructor.parameters.leftParenthesis.end;
         if (parameters.isNotEmpty) {
           fieldParametersCode += ', ';
         }
         builder.addSimpleInsertion(offset, fieldParametersCode);
       }
     });
     _addFixFromBuilder(changeBuilder, DartFixKind.ADD_FIELD_FORMAL_PARAMETERS);
   }
 
   Future<Null> _addFix_useEffectiveIntegerDivision() async {
     for (AstNode n = node; n != null; n = n.parent) {
       if (n is MethodInvocation &&
           n.offset == errorOffset &&
           n.length == errorLength) {
         Expression target = (n as MethodInvocation).target.unParenthesized;
         DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-        await changeBuilder.addFileEdit(file, fileStamp,
-            (DartFileEditBuilder builder) {
+        await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
           // replace "/" with "~/"
           BinaryExpression binary = target as BinaryExpression;
           builder.addSimpleReplacement(range.token(binary.operator), '~/');
           // remove everything before and after
           builder.addDeletion(range.startStart(n, binary.leftOperand));
           builder.addDeletion(range.endEnd(binary.rightOperand, n));
         });
         _addFixFromBuilder(
             changeBuilder, DartFixKind.USE_EFFECTIVE_INTEGER_DIVISION);
         // done
         break;
       }
     }
   }
 
   /**
    * Adds a fix that replaces [target] with a reference to the class declaring
    * the given [element].
    */
   Future<Null> _addFix_useStaticAccess(AstNode target, Element element) async {
     Element declaringElement = element.enclosingElement;
     if (declaringElement is ClassElement) {
       DartType declaringType = declaringElement.type;
       DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-      await changeBuilder.addFileEdit(file, fileStamp,
-          (DartFileEditBuilder builder) {
+      await changeBuilder.addFileEdit(file, (DartFileEditBuilder builder) {
         // replace "target" with class name
         builder.addReplacement(range.node(target), (DartEditBuilder builder) {
           builder.writeType(declaringType);
         });
       });
       _addFixFromBuilder(changeBuilder, DartFixKind.CHANGE_TO_STATIC_ACCESS,
           args: [declaringType]);
     }
   }
 
@@ skipping 38 matching lines @@
       String name,
       Source targetSource,
       int insertOffset,
       bool isStatic,
       String prefix,
       String sourcePrefix,
       String sourceSuffix,
       Element target) async {
     // build method source
     String targetFile = targetSource.fullName;
-    int timeStamp = target.context.getModificationStamp(targetSource);
     DartChangeBuilder changeBuilder = new DartChangeBuilder(driver);
-    await changeBuilder.addFileEdit(targetFile, timeStamp,
-        (DartFileEditBuilder builder) {
+    await changeBuilder.addFileEdit(targetFile, (DartFileEditBuilder builder) {
       builder.addInsertion(insertOffset, (DartEditBuilder builder) {
         builder.write(sourcePrefix);
         builder.write(prefix);
         // may be static
         if (isStatic) {
           builder.write('static ');
         }
         // append return type
         if (builder.writeType(functionType.returnType,
             groupName: 'RETURN_TYPE')) {
@@ skipping 362 matching lines @@
     // This should be rare / never situation.
     if (packageRoot == null) {
       return true;
     }
 
     // We cannot use relative URIs to reference files outside of our package.
     return resourceProvider.pathContext
         .isWithin(packageRoot.path, source.fullName);
   }
 
-  int _modificationStamp(String filePath) {
-    // TODO(brianwilkerson) We have lost the ability for clients to know whether
-    // it is safe to apply an edit.
-    return driver.fsState.getFileForPath(filePath).exists ? 0 : -1;
-  }
-
   /**
    * Removes any [ParenthesizedExpression] enclosing [expr].
    *
    * [exprPrecedence] - the effective precedence of [expr].
    */
   void _removeEnclosingParentheses(
       DartFileEditBuilder builder, Expression expr, int exprPrecedence) {
     while (expr.parent is ParenthesizedExpression) {
       ParenthesizedExpression parenthesized =
           expr.parent as ParenthesizedExpression;
@@ skipping 85 matching lines @@
       }
     }
   }
 
   void _updateList(Iterable<Element> elements) {
     for (Element element in elements) {
       _update(element);
     }
   }
 }