Remove compile-time error for unresolved factory names (issue 3079).

runtime/vm/class_finalizer.cc

 // Copyright (c) 2012, 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.
 
 #include "vm/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 803 matching lines @@
   }
 
   return parameterized_type.Canonicalize();
 }
 
 
 void ClassFinalizer::ResolveAndFinalizeSignature(const Class& cls,
                                                  const Function& function) {
   // Resolve result type.
   AbstractType& type = AbstractType::Handle(function.result_type());
-  FinalizationKind result_finalization = kFinalize;
-  if (function.IsFactory()) {
-    // The name of a factory must always be resolved to a class or interface.
-    // The parser sets the factory result type to a type with an unresolved
-    // class whose name matches the factory name.
-    result_finalization = kFinalizeWellFormed;
-    // TODO(regis): Gilad asks if this compile-time error could be relaxed.
-    // The result type of such a factory method would simply be malformed.
-  }
-  ResolveType(cls, type, result_finalization);
-  type = FinalizeType(cls, type, result_finalization);
+  // In case of a factory, the parser sets the factory result type to a type
+  // with an unresolved class whose name matches the factory name.
+  // It is not a compile time error if this name does not resolve to a class or
+  // interface.
+  ResolveType(cls, type, kFinalize);
+  type = FinalizeType(cls, type, kFinalize);
   // In production mode, a malformed result type is mapped to Dynamic.
   if (!FLAG_enable_type_checks && type.IsMalformed()) {
     type = Type::DynamicType();
   }
   function.set_result_type(type);
   // Resolve formal parameter types.
   const intptr_t num_parameters = function.NumberOfParameters();
   for (intptr_t i = 0; i < num_parameters; i++) {
     type = function.ParameterTypeAt(i);
     ResolveType(cls, type, kFinalize);
@@ skipping 646 matching lines @@
 void ClassFinalizer::ReportError(const char* format, ...) {
   va_list args;
   va_start(args, format);
   const Error& error = Error::Handle(
       Parser::FormatError(Script::Handle(), -1, "Error", format, args));
   va_end(args);
   ReportError(error);
 }
 
 }  // namespace dart