Use a Levenshtein calculating algorithm with a threshold.

pkg/analysis_services/lib/src/correction/fix.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library services.src.correction.fix;
 
 import 'package:analysis_services/correction/change.dart';
@@ skipping 1011 matching lines @@
       var instanceCreation = coveredNode as InstanceCreationExpression;
       _addReplaceEdit(rf.rangeToken(instanceCreation.keyword), "const");
       _addFix(FixKind.USE_CONST, []);
     }
   }
 
   void _addFix_undefinedClass_useSimilar() {
     if (_mayBeTypeIdentifier(node)) {
       String name = (node as SimpleIdentifier).name;
       _ClosestElementFinder finder =
-          new _ClosestElementFinder(name, (Element element) => element is ClassElement);
+          new _ClosestElementFinder(
+              name,
+              (Element element) => element is ClassElement,
+              5);
       // find closest element
       {
         // elements of this library
         for (CompilationUnitElement unit in unitLibraryElement.units) {
           finder._updateList(unit.types);
         }
         // elements from imports
         for (ImportElement importElement in unitLibraryElement.imports) {
           if (importElement.prefix == null) {
             Map<String, Element> namespace = getImportNamespace(importElement);
             finder._updateList(namespace.values);
           }
         }
       }
       // if we have close enough element, suggest to use it
-      if (finder != null && finder._distance < 5) {
+      if (finder._element != null) {

[Paul Berry, 2014/07/25 19:53:26]

I think this introduces an unintentional off-by-one semantic change. 
Previously, we only accepted elements whose edit distance was *less than* 5.  We
now accept elements whose edit distance is *less than or equal to* 5.

[scheglov, 2014/07/25 21:18:24]

Done.

         String closestName = finder._element.name;
         _addReplaceEdit(rf.rangeNode(node), closestName);
         // add proposal
         if (closestName != null) {
           _addFix(FixKind.CHANGE_TO, [closestName]);
         }
       }
     }
   }
 
@@ skipping 41 matching lines @@
     // add proposal
     _addFix(FixKind.CREATE_FUNCTION, [name]);
   }
 
   void _addFix_undefinedFunction_useSimilar() {
     if (node is SimpleIdentifier) {
       String name = (node as SimpleIdentifier).name;
       _ClosestElementFinder finder =
           new _ClosestElementFinder(
               name,
-              (Element element) => element is FunctionElement);
+              (Element element) => element is FunctionElement,
+              5);
       // this library
       for (CompilationUnitElement unit in unitLibraryElement.units) {
         finder._updateList(unit.functions);
       }
       // imports
       for (ImportElement importElement in unitLibraryElement.imports) {
         if (importElement.prefix == null) {
           Map<String, Element> namespace = getImportNamespace(importElement);
           finder._updateList(namespace.values);
         }
       }
       // if we have close enough element, suggest to use it
-      String closestName = null;
-      if (finder != null && finder._distance < 5) {
-        closestName = finder._element.name;
+      if (finder._element != null) {
+        String closestName = finder._element.name;
         _addReplaceEdit(rf.rangeNode(node), closestName);
         _addFix(FixKind.CHANGE_TO, [closestName]);
       }
     }
   }
 
   void _addFix_undefinedMethod_create() {
     if (node is SimpleIdentifier && node.parent is MethodInvocation) {
       String name = (node as SimpleIdentifier).name;
       MethodInvocation invocation = node.parent as MethodInvocation;
@@ skipping 104 matching lines @@
         sb.endPosition();
       }
     }
   }
 
   void _addFix_undefinedMethod_useSimilar() {
     if (node is SimpleIdentifier && node.parent is MethodInvocation) {
       MethodInvocation invocation = node.parent as MethodInvocation;
       String name = (node as SimpleIdentifier).name;
       _ClosestElementFinder finder =
-          new _ClosestElementFinder(name, (Element element) {
-        return element is MethodElement && !element.isOperator;
-      });
+          new _ClosestElementFinder(
+              name,
+              (Element element) => element is MethodElement && !element.isOperator,
+              5);
       // unqualified invocation
       Expression target = invocation.realTarget;
       if (target == null) {
         ClassDeclaration clazz =
             invocation.getAncestor((node) => node is ClassDeclaration);
         if (clazz != null) {
           ClassElement classElement = clazz.element;
           _updateFinderWithClassMembers(finder, classElement);
         }
       } else {
         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
-      String closestName = null;
-      if (finder != null && finder._distance < 5) {
-        closestName = finder._element.name;
+      if (finder._element != null) {
+        String closestName = finder._element.name;
         _addReplaceEdit(rf.rangeNode(node), closestName);
         _addFix(FixKind.CHANGE_TO, [closestName]);
       }
     }
   }
 
   void _addFix_useEffectiveIntegerDivision() {
     for (AstNode n = node; n != null; n = n.parent) {
       if (n is MethodInvocation &&
           n.offset == errorOffset &&
@@ skipping 633 matching lines @@
 }
 
 /**
  * Helper for finding [Element] with name closest to the given.
  */
 class _ClosestElementFinder {
   final String _targetName;
   final Predicate<Element> _predicate;
 
   Element _element = null;
-  int _distance = 1 << 10;
+  int _distance;
 
-  _ClosestElementFinder(this._targetName, this._predicate);
+  _ClosestElementFinder(this._targetName, this._predicate, this._distance);
 
   void _update(Element element) {
     if (_predicate(element)) {
-      int memberDistance = getLevenshteinDistance(element.name, _targetName);
+      int memberDistance = levenshtein(element.name, _targetName, _distance);
       if (memberDistance < _distance) {
         _element = element;
         _distance = memberDistance;
       }
     }
   }
 
   void _updateList(Iterable<Element> elements) {
     for (Element element in elements) {
       _update(element);
     }
   }
 }
 
 /**
  * Describes the location for a newly created [ConstructorDeclaration].
  */
 class _ConstructorLocation {
   final String _prefix;
   final int _offset;
   final String _suffix;
 
   _ConstructorLocation(this._prefix, this._offset, this._suffix);
 }