Switching foreign function to be marked as functions at call sites.

src/typing-asm.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/typing-asm.h"
 
 #include <limits>
 
 #include "src/v8.h"
 
@@ skipping 982 matching lines @@
       // Checking for asm extern types explicitly, as the type system
       // doesn't correctly check their inheritance relationship.
       if (!computed_type_->Is(cache_.kAsmSigned) &&
           !computed_type_->Is(cache_.kAsmFixnum) &&
           !computed_type_->Is(cache_.kAsmDouble)) {
         FAIL(arg,
              "foreign call argument expected to be int, double, or fixnum");
       }
     }
     intish_ = kMaxUncombinedAdditiveSteps;
+    expr->expression()->set_bounds(Bounds(Type::Function(zone())));
     IntersectResult(expr, expected_type);
   } else {
     FAIL(expr, "invalid callee");
   }
 }
 
 
 void AsmTyper::VisitCallNew(CallNew* expr) {
   if (in_function_) {
     FAIL(expr, "new not allowed in module function");
@@ skipping 115 matching lines @@
       return;
     }
     case Token::OR:
     case Token::AND:
       FAIL(expr, "illegal logical operator");
     case Token::BIT_OR: {
       // BIT_OR allows Any since it is used as a type coercion.
       VisitIntegerBitwiseOperator(expr, Type::Any(zone()), cache_.kAsmInt,
                                   cache_.kAsmSigned, true);
       if (expr->left()->IsCall() && expr->op() == Token::BIT_OR) {
-        IntersectResult(expr->left(), cache_.kAsmSigned);
+        expr->left()->set_bounds(Bounds(cache_.kAsmSigned));
       }
       return;
     }
     case Token::BIT_XOR: {
       // Handle booleans specially to handle de-sugared !
       Literal* left = expr->left()->AsLiteral();
       if (left && left->value()->IsBoolean()) {
         if (left->ToBooleanIsTrue()) {
           left->set_bounds(Bounds(cache_.kSingletonOne));
           RECURSE(VisitWithExpectation(expr->right(), cache_.kAsmInt,
@@ skipping 68 matching lines @@
               FAIL(expr, "too many consecutive multiplicative ops");
             }
           }
           IntersectResult(expr, cache_.kAsmInt);
           return;
         }
       } else if (expr->op() == Token::MUL && expr->right()->IsLiteral() &&
                  right_type->Is(cache_.kAsmDouble)) {
         // For unary +, expressed as x * 1.0
         if (expr->left()->IsCall() && expr->op() == Token::MUL) {
-          IntersectResult(expr->left(), cache_.kAsmDouble);
+          expr->left()->set_bounds(Bounds(cache_.kAsmDouble));
         }
         IntersectResult(expr, cache_.kAsmDouble);
         return;
       } else if (type->Is(cache_.kAsmFloat) && expr->op() != Token::MOD) {
         if (left_intish != 0 || right_intish != 0) {
           FAIL(expr, "float operation before required fround");
         }
         IntersectResult(expr, cache_.kAsmFloat);
         intish_ = 1;
         return;
@@ skipping 293 matching lines @@
 
 
 void AsmTyper::VisitRewritableAssignmentExpression(
     RewritableAssignmentExpression* expr) {
   RECURSE(Visit(expr->expression()));
 }
 
 
 }  // namespace internal
 }  // namespace v8