Integrate EXTRACT_METHOD refactoring into the server.

pkg/analysis_server/lib/src/edit/edit_domain.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 edit.domain;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/constants.dart';
@@ skipping 93 matching lines @@
       if (errorInfo != null) {
         LineInfo lineInfo = errorInfo.lineInfo;
         int requestLine = lineInfo.getLocation(offset).lineNumber;
         for (engine.AnalysisError error in errorInfo.errors) {
           int errorLine = lineInfo.getLocation(error.offset).lineNumber;
           if (errorLine == requestLine) {
             List<Fix> fixes = computeFixes(searchEngine, unit, error);
             if (fixes.isNotEmpty) {
               AnalysisError serverError =
                   new AnalysisError.fromEngine(lineInfo, error);
-              AnalysisErrorFixes errorFixes = new AnalysisErrorFixes(serverError);
+              AnalysisErrorFixes errorFixes =
+                  new AnalysisErrorFixes(serverError);
               errorFixesList.add(errorFixes);
               fixes.forEach((fix) {
                 errorFixes.addFix(fix);
               });
             }
           }
         }
       }
     }
     // respond
@@ skipping 115 matching lines @@
     this.offset = offset;
     this.length = length;
     // create a new Refactoring instance
     if (kind == RefactoringKind.EXTRACT_LOCAL_VARIABLE) {
       List<CompilationUnit> units = server.getResolvedCompilationUnits(file);
       if (units.isNotEmpty) {
         refactoring = new ExtractLocalRefactoring(units[0], offset, length);
         feedback = new ExtractLocalVariableFeedback([], [], []);
       }
     }
+    if (kind == RefactoringKind.EXTRACT_METHOD) {
+      List<CompilationUnit> units = server.getResolvedCompilationUnits(file);
+      if (units.isNotEmpty) {
+        refactoring =
+            new ExtractMethodRefactoring(searchEngine, units[0], offset, length);
+        feedback =
+            new ExtractMethodFeedback(offset, length, null, [], false, [], [], []);
+      }
+    }
     if (kind == RefactoringKind.RENAME) {
       List<AstNode> nodes = server.getNodesAtOffset(file, offset);
       List<Element> elements = server.getElementsAtOffset(file, offset);
       if (nodes.isNotEmpty && elements.isNotEmpty) {
         AstNode node = nodes[0];
         Element element = elements[0];
         refactoring = new RenameRefactoring(searchEngine, element);
         feedback = new RenameFeedback(node.offset, node.length);
       }
     }
     if (refactoring == null) {
       initStatus =
           new RefactoringStatus.fatal('Unable to create a refactoring');
       return new Future.value(initStatus);
     }
     // check initial conditions
     return refactoring.checkInitialConditions().then((status) {
       initStatus = status;
       if (refactoring is ExtractLocalRefactoring) {
         ExtractLocalRefactoring refactoring = this.refactoring;
         ExtractLocalVariableFeedback feedback = this.feedback;
         feedback.names = refactoring.names;
         feedback.offsets = refactoring.offsets;
         feedback.lengths = refactoring.lengths;
       }
+      if (refactoring is ExtractMethodRefactoring) {
+        ExtractMethodRefactoring refactoring = this.refactoring;
+        ExtractMethodFeedback feedback = this.feedback;
+        feedback.canCreateGetter = refactoring.canCreateGetter;
+        feedback.returnType = refactoring.returnType;
+        feedback.names = refactoring.names;
+        feedback.parameters = refactoring.parameters;
+        feedback.offsets = refactoring.offsets;
+        feedback.lengths = refactoring.lengths;
+      }
       return initStatus;
     });
   }
 
   void _reset() {
     refactoring = null;
     feedback = null;
     initStatus = new RefactoringStatus();
     optionsStatus = new RefactoringStatus();
     finalStatus = new RefactoringStatus();
@@ skipping 10 matching lines @@
       result.problems = status.problems;
     }
     // send the response
     server.sendResponse(result.toResponse(requestId));
     // done with this request
     requestId = null;
     result = null;
   }
 
   RefactoringStatus _setOptions(EditGetRefactoringParams params,
-                                Request request) {
+      Request request) {
     if (refactoring is ExtractLocalRefactoring) {
       ExtractLocalRefactoring extractRefactoring = refactoring;
       ExtractLocalVariableOptions extractOptions =
           new ExtractLocalVariableOptions.fromRefactoringParams(params, request);
       extractRefactoring.name = extractOptions.name;
       extractRefactoring.extractAll = extractOptions.extractAll;
       return extractRefactoring.checkName();
     }
+    if (refactoring is ExtractMethodRefactoring) {
+      ExtractMethodRefactoring extractRefactoring = this.refactoring;
+      ExtractMethodOptions extractOptions =
+          new ExtractMethodOptions.fromRefactoringParams(params, request);
+      extractRefactoring.createGetter = extractOptions.createGetter;
+      extractRefactoring.extractAll = extractOptions.extractAll;
+      extractRefactoring.name = extractOptions.name;
+      if (extractOptions.parameters != null) {
+        extractRefactoring.parameters = extractOptions.parameters;
+      }
+      extractRefactoring.returnType = extractOptions.returnType;
+      return extractRefactoring.checkName();
+    }
     if (refactoring is RenameRefactoring) {
       RenameRefactoring renameRefactoring = refactoring;
       RenameOptions renameOptions =
           new RenameOptions.fromRefactoringParams(params, request);
       renameRefactoring.newName = renameOptions.newName;
       return renameRefactoring.checkNewName();
     }
     return new RefactoringStatus();
   }
 }