Constant-fold !<number>

src/parser.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 2537 matching lines @@
     if (expression != NULL && expression->AsLiteral() &&
         expression->AsLiteral()->handle()->IsNumber()) {
       double value = expression->AsLiteral()->handle()->Number();
       switch (op) {
         case Token::ADD:
           return expression;
         case Token::SUB:
           return NewNumberLiteral(-value);
         case Token::BIT_NOT:
           return NewNumberLiteral(~DoubleToInt32(value));
+        case Token::NOT:
+          if (value == 0) {

[Kasper Lund, 2011/06/10 09:20:08]

Could this be something ala:

   Handle<Object> boolean(isolate->heap()->ToBoolean(value == 0));
   return new(zone()) Literal(boolean);

or perhaps consider negating the result of calling
expression->AsLiteral()->handle()->ToBoolean() and refactoring the code so it
works for cases where the expression is a non-numeric literal.

[Kevin Millikin (Chromium), 2011/06/10 10:05:14]

We already have this constant folding in void
FullCodeGenerator::TestContext::Plug(Handle<Object> lit).  It just needs to be
'ported' to TestContext::BuildBranch(HValue* value) in hydrogen.cc.

I would prefer that solution rather than having it here, because it can properly
cope with things like

x = 0
if (!x) ...

+            return new(zone()) Literal(isolate()->factory()->true_value());
+          } else {
+            return new(zone()) Literal(isolate()->factory()->false_value());
+          }
         default: break;
       }
     }
 
     // "delete identifier" is a syntax error in strict mode.
     if (op == Token::DELETE && top_scope_->is_strict_mode()) {
       VariableProxy* operand = expression->AsVariableProxy();
       if (operand != NULL && !operand->is_this()) {
         ReportMessage("strict_delete", Vector<const char*>::empty());
         *ok = false;
@@ skipping 2422 matching lines @@
                                    info->is_global(),
                                    info->StrictMode());
     }
   }
 
   info->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal