Issue 19682. New analyzer snapshot that fixes an inline refactoring problem.

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 5267 matching lines @@
    * An array containing the actual types of the type arguments.
    */
   List<DartType> typeArguments = TypeImpl.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created function type to be declared by the given element and to have the
    * given name.
    *
    * @param element the element representing the declaration of the function type
    */
-  FunctionTypeImpl.con1(ExecutableElement element) : super(element, element == null ? null : element.name);
+  FunctionTypeImpl.con1(ExecutableElement element) : super(element, null);
 
   /**
    * Initialize a newly created function type to be declared by the given element and to have the
    * given name.
    *
    * @param element the element representing the declaration of the function type
    */
   FunctionTypeImpl.con2(FunctionTypeAliasElement element) : super(element, element == null ? null : element.name);
 
   @override
@@ skipping 5811 matching lines @@
   Set<DartType> get elements;
 }
 
 /**
  * In addition to the methods of the `UnionType` interface we add a factory method
  * `union` for building unions.
  */
 class UnionTypeImpl extends TypeImpl implements UnionType {
   /**
    * Any unions in the `types` will be flattened in the returned union. If there is only one
-   * type after flattening then it will be returned directly, instead of a singleton union.
+   * type after flattening then it will be returned directly, instead of a singleton union. Nulls
+   * are discarded, unless all types are null, in which case an exception is raised.
    *
    * @param types the `Type`s to union
    * @return a `Type` comprising the `Type`s in `types`
    */
   static DartType union(List<DartType> types) {
     Set<DartType> set = new HashSet<DartType>();
     for (DartType t in types) {
       if (t is UnionType) {
         set.addAll(t.elements);
       } else {
-        set.add(t);
+        if (t != null) {
+          set.add(t);
+        }
       }
     }
     if (set.length == 0) {
+      // TODO(collinsn): better to return [null] here? The use case is e.g.
+      //
+      //   union(null, null) ==> null;
+      //
+      // instead of raising an exception.
       throw new IllegalArgumentException("No known use case for empty unions.");
     } else if (set.length == 1) {
       return new JavaIterator(set).next();
     } else {
       return new UnionTypeImpl(set);
     }
   }
 
   /**
    * The types in this union.
@@ skipping 490 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);
   }
 }