Support for inlining methods when some arguments are missing.

pkg/analysis_server/lib/src/services/refactoring/inline_method.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.refactoring.inline_method;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/protocol_server.dart' hide Element;
 import 'package:analysis_server/src/services/correction/source_range.dart';
 import 'package:analysis_server/src/services/correction/status.dart';
 import 'package:analysis_server/src/services/correction/strings.dart';
 import 'package:analysis_server/src/services/correction/util.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring_internal.dart';
 import 'package:analysis_server/src/services/search/element_visitors.dart';
 import 'package:analysis_server/src/services/search/hierarchy.dart';
 import 'package:analysis_server/src/services/search/search_engine.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/utilities_dart.dart';
 
 
 /**
  * Returns the [SourceRange] to find conflicting locals in.
  */
 SourceRange _getLocalsConflictingRange(AstNode node) {
   // maybe Block
   Block block = node.getAncestor((node) => node is Block);
   if (block != null) {
     int offset = node.offset;
     int endOffset = block.end;
     return rangeStartEnd(offset, endOffset);
   }
   // maybe whole executable
   AstNode executableNode = getEnclosingExecutableNode(node);
   if (executableNode != null) {
     return rangeNode(executableNode);
   }
   // not a part of a declaration with locals
   return SourceRange.EMPTY;
 }
 
 
 /**
  * Returns the source which should replace given invocation with given
  * arguments.
  */
-String _getMethodSourceForInvocation(_SourcePart part, CorrectionUtils utils,
-    AstNode contextNode, Expression targetExpression, List<Expression> arguments) {
+String _getMethodSourceForInvocation(RefactoringStatus status, _SourcePart part,
+    CorrectionUtils utils, AstNode contextNode, Expression targetExpression,
+    List<Expression> arguments) {
   // prepare edits to replace parameters with arguments
   List<SourceEdit> edits = <SourceEdit>[];
   part._parameters.forEach(
       (ParameterElement parameter, List<_ParameterOccurrence> occurrences) {
     // prepare argument
     Expression argument = null;
     for (Expression arg in arguments) {
       if (arg.bestParameterElement == parameter) {
         argument = arg;
         break;
       }
     }
     if (argument is NamedExpression) {
       argument = (argument as NamedExpression).expression;
     }
-    int argumentPrecedence = getExpressionPrecedence(argument);
-    String argumentSource = utils.getNodeText(argument);
+    // prepare argument properties
+    int argumentPrecedence;
+    String argumentSource;
+    if (argument != null) {
+      argumentPrecedence = getExpressionPrecedence(argument);
+      argumentSource = utils.getNodeText(argument);
+    } else {
+      // report about a missing required parameter
+      if (parameter.parameterKind == ParameterKind.REQUIRED) {
+        status.addError(
+            'No argument for the parameter "${parameter.name}".',
+            newLocation_fromNode(contextNode));
+        return;
+      }
+      // an optional parameter
+      argumentPrecedence = -1000;
+      argumentSource = parameter.defaultValueCode;
+      if (argumentSource == null) {
+        argumentSource = 'null';
+      }
+    }
     // replace all occurrences of this parameter
     for (_ParameterOccurrence occurrence in occurrences) {
       SourceRange range = occurrence.range;
       // prepare argument source to apply at this occurrence
       String occurrenceArgumentSource;
       if (argumentPrecedence < occurrence.parentPrecedence) {
-        occurrenceArgumentSource = "(${argumentSource})";
+        occurrenceArgumentSource = "($argumentSource)";
       } else {
         occurrenceArgumentSource = argumentSource;
       }
       // do replace
       edits.add(newSourceEdit_range(range, occurrenceArgumentSource));
     }
   });
   // replace static field "qualifier" with invocation target
   part._staticFieldQualifiers.forEach(
       (String className, List<SourceRange> ranges) {
@@ skipping 396 matching lines @@
       status.addError(
           'Cannot inline cascade invocation.',
           newLocation_fromNode(usage));
     }
     // can we inline method body into "methodUsage" block?
     if (_canInlineBody(usage)) {
       // insert non-return statements
       if (ref._methodStatementsPart != null) {
         // prepare statements source for invocation
         String source = _getMethodSourceForInvocation(
+            status,
             ref._methodStatementsPart,
             _refUtils,
             usage,
             target,
             arguments);
         source = _refUtils.replaceSourceIndent(
             source,
             ref._methodStatementsPart._prefix,
             _refPrefix);
         // do insert
         SourceRange range = rangeStartLength(_refLineRange, 0);
         SourceEdit edit = newSourceEdit_range(range, source);
         _addRefEdit(edit);
       }
       // replace invocation with return expression
       if (ref._methodExpressionPart != null) {
         // prepare expression source for invocation
         String source = _getMethodSourceForInvocation(
+            status,
             ref._methodExpressionPart,
             _refUtils,
             usage,
             target,
             arguments);
         if (getExpressionPrecedence(ref._methodExpression) <
             getExpressionParentPrecedence(usage)) {
           source = "(${source})";
         }
         // do replace
@@ skipping 284 matching lines @@
   }
 
   void _addVariable(SimpleIdentifier node) {
     VariableElement variableElement = getLocalVariableElement(node);
     if (variableElement != null) {
       SourceRange nodeRange = rangeNode(node);
       result.addVariable(variableElement, nodeRange);
     }
   }
 }