Fix type checking of void type.

runtime/vm/flow_graph_compiler_ia32.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_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "lib/error.h"
@@ skipping 403 matching lines @@
 // - preserved instance in EAX and optional instantiator type arguments in EDX.
 // 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()) {
+    return SubtypeTestCache::null();

[srdjan, 2012/07/16 15:21:12]

When can the type we check agains be void?

[regis, 2012/07/16 18:05:34]

When we type check a value returned from a void function. Note that we will not
reach here if the returned value is null, since this case is handled by the
inlined code. So this case will result in a type error.
I have added a comment.
Remember also that this helper is used in both 'instance of' and 'check
assignable'.

+  }
   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);
     }
-  } else {
-    return GenerateUninstantiatedTypeTest(cid,
-                                          token_pos,
-                                          type,
-                                          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);
   }
-  return SubtypeTestCache::null();
+  return GenerateUninstantiatedTypeTest(cid,
+                                        token_pos,
+                                        type,
+                                        is_instance_lbl,
+                                        is_not_instance_lbl);
 }
 
 
 // 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:
 // - EAX: 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());
   __ pushl(ECX);  // Store instantiator.
   __ pushl(EDX);  // 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;
   __ cmpl(EAX, raw_null);
   __ j(EQUAL, &is_assignable);
 
   // Generate throw new TypeError() if the type is malformed.
@@ skipping 563 matching lines @@
     }
   }
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32