Issue 17389. Analyzer snapshot and server tweaks to use new ParameterElement.defaultValueCode.

pkg/analyzer/lib/src/generated/element.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 engine.element;
 
 import 'dart:collection';
@@ skipping 9085 matching lines @@
    */
   static final List<NamespaceCombinator> EMPTY_ARRAY = new List<NamespaceCombinator>(0);
 }
 
 /**
  * The interface `ParameterElement` defines the behavior of elements representing a parameter
  * defined within an executable element.
  */
 abstract class ParameterElement implements LocalElement, VariableElement {
   /**
-   * Return a source range that covers the portion of the source in which the default value for this
-   * parameter is specified, or `null` if there is no default value.
+   * Return the Dart code of the default value, or `null` if no default value.
    *
-   * @return the range of characters in which the default value of this parameter is specified
+   * @return the Dart code of the default value
    */
-  SourceRange get defaultValueRange;
+  String get defaultValueCode;
 
   /**
    * Return the kind of this parameter.
    *
    * @return the kind of this parameter
    */
   ParameterKind get parameterKind;
 
   /**
    * Return an array containing all of the parameters defined by this parameter. A parameter will
@@ skipping 20 matching lines @@
    * parameters if this parameter is a function typed parameter.
    */
   List<ParameterElement> _parameters = ParameterElementImpl.EMPTY_ARRAY;
 
   /**
    * The kind of this parameter.
    */
   ParameterKind parameterKind;
 
   /**
-   * The offset to the beginning of the default value range for this element.
+   * The Dart code of the default value.
    */
-  int _defaultValueRangeOffset = 0;
-
-  /**
-   * The length of the default value range for this element, or `-1` if this element does not
-   * have a default value.
-   */
-  int _defaultValueRangeLength = -1;
+  String _defaultValueCode;
 
   /**
    * The offset to the beginning of the visible range for this element.
    */
   int _visibleRangeOffset = 0;
 
   /**
    * The length of the visible range for this element, or `-1` if this element does not have a
    * visible range.
    */
@@ skipping 27 matching lines @@
   ElementImpl getChild(String identifier) {
     for (ParameterElement parameter in _parameters) {
       if ((parameter as ParameterElementImpl).identifier == identifier) {
         return parameter as ParameterElementImpl;
       }
     }
     return null;
   }
 
   @override
-  SourceRange get defaultValueRange {
-    if (_defaultValueRangeLength < 0) {
-      return null;
-    }
-    return new SourceRange(_defaultValueRangeOffset, _defaultValueRangeLength);
-  }
+  String get defaultValueCode => _defaultValueCode;
 
   @override
   ElementKind get kind => ElementKind.PARAMETER;
 
   @override
   List<ParameterElement> get parameters => _parameters;
 
   @override
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
@@ skipping 19 matching lines @@
   }
 
   /**
    * Specifies that this variable is potentially mutated somewhere in its scope.
    */
   void markPotentiallyMutatedInScope() {
     setModifier(Modifier.POTENTIALLY_MUTATED_IN_SCOPE, true);
   }
 
   /**
-   * Set the range of the default value for this parameter to the range starting at the given offset
-   * with the given length.
-   *
-   * @param offset the offset to the beginning of the default value range for this element
-   * @param length the length of the default value range for this element, or `-1` if this
-   *          element does not have a default value
+   * Set Dart code of the default value.
    */
-  void setDefaultValueRange(int offset, int length) {
-    _defaultValueRangeOffset = offset;
-    _defaultValueRangeLength = length;
+  void set defaultValueCode(String defaultValueCode) {
+    this._defaultValueCode = StringUtilities.intern(defaultValueCode);
   }
 
   /**
    * Set the parameters defined by this executable element to the given parameters.
    *
    * @param parameters the parameters defined by this executable element
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
@@ skipping 42 matching lines @@
 
   /**
    * Append the type and name of this parameter to the given builder.
    *
    * @param builder the builder to which the type and name are to be appended
    */
   void appendToWithoutDelimiters(JavaStringBuilder builder) {
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
+    if (_defaultValueCode != null) {
+      if (parameterKind == ParameterKind.NAMED) {
+        builder.append(": ");
+      }
+      if (parameterKind == ParameterKind.POSITIONAL) {
+        builder.append(" = ");
+      }
+      builder.append(_defaultValueCode);
+    }
   }
 }
 
 /**
  * Instances of the class `ParameterMember` represent a parameter element defined in a
  * parameterized type where the values of the type parameters are known.
  */
 class ParameterMember extends VariableMember implements ParameterElement {
   /**
    * If the given parameter's type is different when any type parameters from the defining type's
@@ skipping 55 matching lines @@
         return PropertyAccessorMember.from(element, definingInterfaceType);
       }
     }
     return element;
   }
 
   @override
   ParameterElement get baseElement => super.baseElement as ParameterElement;
 
   @override
-  SourceRange get defaultValueRange => baseElement.defaultValueRange;
+  String get defaultValueCode => baseElement.defaultValueCode;
 
   @override
   Element get enclosingElement => baseElement.enclosingElement;
 
   @override
   ParameterKind get parameterKind => baseElement.parameterKind;
 
   @override
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = baseElement.parameters;
@@ skipping 2232 matching lines @@
     if (type is UnionType) {
       return (type as UnionTypeImpl).internalUnionTypeIsSuperTypeOf(this, visitedTypePairs);
     }
     // The only subtype relations that pertain to void are therefore:
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || identical(type, DynamicTypeImpl.instance);
   }
 }