Revert fix for type checking of void type, because some top level tests fail.

runtime/vm/flow_graph_compiler_x64.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/globals.h"  // Needed here to get TARGET_ARCH_X64.
 #if defined(TARGET_ARCH_X64)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 403 matching lines @@
 // - preserved instance in RAX and optional instantiator type arguments in RDX.
 // Note that this inlined code must be followed by the runtime_call code, as it
 // may fall through to it. Otherwise, this inline code will jump to the label
 // is_instance or to the label is_not_instance.
 RawSubtypeTestCache* FlowGraphCompiler::GenerateInlineInstanceof(
     intptr_t cid,
     intptr_t token_pos,
     const AbstractType& type,
     Label* is_instance_lbl,
     Label* is_not_instance_lbl) {
-  if (type.IsVoidType()) {
-    // A non-null value is returned from a void function, which will result in a
-    // type error. A null value is handled prior to executing this inline code.
-    return SubtypeTestCache::null();
-  }
   if (type.IsInstantiated()) {
     const Class& type_class = Class::ZoneHandle(type.type_class());
     // A Smi object cannot be the instance of a parameterized class.
     // A class equality check is only applicable with a dst type of a
     // non-parameterized class or with a raw dst type of a parameterized class.
     if (type_class.HasTypeArguments()) {
       return GenerateInstantiatedTypeWithArgumentsTest(cid,
                                                        token_pos,
                                                        type,
                                                        is_instance_lbl,
                                                        is_not_instance_lbl);
       // Fall through to runtime call.
+    } else {
+      GenerateInstantiatedTypeNoArgumentsTest(cid,
+                                              token_pos,
+                                              type,
+                                              is_instance_lbl,
+                                              is_not_instance_lbl);
+      // If test non-conclusive so far, try the inlined type-test cache.
+      // 'type' is known at compile time.
+      return GenerateSubtype1TestCacheLookup(
+          cid, token_pos, type_class,
+          is_instance_lbl, is_not_instance_lbl);
     }
-    GenerateInstantiatedTypeNoArgumentsTest(cid,
-                                            token_pos,
-                                            type,
-                                            is_instance_lbl,
-                                            is_not_instance_lbl);
-    // If test non-conclusive so far, try the inlined type-test cache.
-    // 'type' is known at compile time.
-    return GenerateSubtype1TestCacheLookup(
-        cid, token_pos, type_class,
-        is_instance_lbl, is_not_instance_lbl);
+  } else {
+    return GenerateUninstantiatedTypeTest(cid,
+                                          token_pos,
+                                          type,
+                                          is_instance_lbl,
+                                          is_not_instance_lbl);
   }
-  return GenerateUninstantiatedTypeTest(cid,
-                                        token_pos,
-                                        type,
-                                        is_instance_lbl,
-                                        is_not_instance_lbl);
+  return SubtypeTestCache::null();
 }
 
 
 // If instanceof type test cannot be performed successfully at compile time and
 // therefore eliminated, optimize it by adding inlined tests for:
 // - NULL -> return false.
 // - Smi -> compile time subtype check (only if dst class is not parameterized).
 // - Class equality (only if class is not parameterized).
 // Inputs:
 // - RAX: object.
@@ skipping 88 matching lines @@
                                                  intptr_t token_pos,
                                                  intptr_t try_index,
                                                  const AbstractType& dst_type,
                                                  const String& dst_name) {
   ASSERT(token_pos >= 0);
   ASSERT(!dst_type.IsNull());
   ASSERT(dst_type.IsFinalized());
   // Assignable check is skipped in FlowGraphBuilder, not here.
   ASSERT(dst_type.IsMalformed() ||
          (!dst_type.IsDynamicType() && !dst_type.IsObjectType()));
+  ASSERT(!dst_type.IsVoidType());
   __ pushq(RCX);  // Store instantiator.
   __ pushq(RDX);  // Store instantiator type arguments.
   // A null object is always assignable and is returned as result.
   const Immediate raw_null =
       Immediate(reinterpret_cast<intptr_t>(Object::null()));
   Label is_assignable, runtime_call;
   __ cmpq(RAX, raw_null);
   __ j(EQUAL, &is_assignable);
 
   // Generate throw new TypeError() if the type is malformed.
@@ skipping 566 matching lines @@
     }
   }
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_X64