anchor.diff:              astFactory.constructorName(typeName, null, null);
           InstanceCreationExpression instanceCreationExpression =
               astFactory.instanceCreationExpression(
  -                _getKeyword(node), constructorName, node.argumentList);
  +                null, constructorName, node.argumentList);
           NodeReplacer.replace(node, instanceCreationExpression);
         } else if (element is ExtensionElement) {
           ExtensionOverride extensionOverride = astFactory.extensionOverride(
  
positive.code:                 astFactory.constructorName(typeName, node.operator, methodName);
              InstanceCreationExpression instanceCreationExpression =
                  astFactory.instanceCreationExpression(
                      _getKeyword(node), constructorName, node.argumentList);
              NodeReplacer.replace(node, instanceCreationExpression);
            }
          }
        }
      }
    }
  
    /// Return the token that should be used in the [InstanceCreationExpression]
    /// that corresponds to the given invocation [node].
    Token _getKeyword(MethodInvocation node) {
      return addConstKeyword
          ? new KeywordToken(Keyword.CONST, node.offset)
          : null;
    }
  
    /// Return the type of the given class [element] after substituting any type
    /// arguments from the list of [typeArguments] for the class' type parameters.
    static InterfaceType getType(TypeSystem typeSystem, ClassElement element,
        TypeArgumentList typeArguments) {
      DartType type = element.type;
  
      List<TypeParameterElement> typeParameters = element.typeParameters;
      if (typeParameters.isEmpty) {
        return type;
      }
  
      if (typeArguments == null) {
        return typeSystem.instantiateToBounds(type);
      }
  
      List<DartType> argumentTypes;
      if (typeArguments.arguments.length == typeParameters.length) {
        argumentTypes = typeArguments.arguments
            .map((TypeAnnotation argument) => argument.type)
            .toList();
      } else {
        argumentTypes = List<DartType>.filled(
            typeParameters.length, DynamicTypeImpl.instance);
      }
      List<DartType> parameterTypes = typeParameters
          .map((TypeParameterElement parameter) => parameter.type)
          .toList();
      return type.substitute2(argumentTypes, parameterTypes);
    }
  }
  
negative.code:           // TODO(scheglov) I think we should drop "typeArguments" below.
            InstanceCreationExpression instanceCreationExpression =
                astFactory.instanceCreationExpression(
                    null, constructorName, node.argumentList,
                    typeArguments: typeArguments);
            NodeReplacer.replace(node, instanceCreationExpression);
          }
  