Adding visitors to regurgitate expression types or reset them.

test/cctest/test-typing-reset.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 <stdlib.h>
+
+#include "src/v8.h"
+
+#include "src/ast.h"
+#include "src/ast-expression-visitor.h"
+#include "src/parser.h"
+#include "src/rewriter.h"
+#include "src/scopes.h"
+#include "src/typing-reset.h"
+#include "test/cctest/cctest.h"
+#include "test/cctest/compiler/function-tester.h"
+#include "test/cctest/expression-type-collector.h"
+
+using namespace v8::internal;
+
+namespace {
+
+class TypeSetter : public AstExpressionVisitor {
+ public:
+  static void Run(CompilationInfo* info) {
+    TypeSetter* visitor = new (info->zone()) TypeSetter(info);
+    visitor->VisitAll();
+  }
+
+ protected:
+  void VisitExpression(Expression* expression) {
+    expression->set_bounds(Bounds(Type::Integral32()));
+  }
+
+ private:
+  explicit TypeSetter(CompilationInfo* info) : AstExpressionVisitor(info) {}
+};
+
+
+void CheckAllSame(ZoneVector<ExpressionTypeEntry>& types,
+                  Bounds expected_type) {
+  HandleAndZoneScope handles;
+  CHECK_TYPES_BEGIN {
+    // function logSum
+    CHECK_EXPR(FunctionLiteral, expected_type) {
+      CHECK_EXPR(FunctionLiteral, expected_type) {
+        CHECK_EXPR(Assignment, expected_type) {
+          CHECK_VAR(start, expected_type);
+          CHECK_EXPR(BinaryOperation, expected_type) {
+            CHECK_VAR(start, expected_type);
+            CHECK_EXPR(Literal, expected_type);
+          }
+        }
+        CHECK_EXPR(Assignment, expected_type) {
+          CHECK_VAR(end, expected_type);
+          CHECK_EXPR(BinaryOperation, expected_type) {
+            CHECK_VAR(end, expected_type);
+            CHECK_EXPR(Literal, expected_type);
+          }
+        }
+        CHECK_EXPR(Assignment, expected_type) {
+          CHECK_VAR(sum, expected_type);
+          CHECK_EXPR(Literal, expected_type);
+        }
+        CHECK_EXPR(Assignment, expected_type) {
+          CHECK_VAR(p, expected_type);
+          CHECK_EXPR(Literal, expected_type);
+        }
+        CHECK_EXPR(Assignment, expected_type) {
+          CHECK_VAR(q, expected_type);
+          CHECK_EXPR(Literal, expected_type);
+        }
+        // for (p = start << 3, q = end << 3;
+        CHECK_EXPR(BinaryOperation, expected_type) {
+          CHECK_EXPR(Assignment, expected_type) {
+            CHECK_VAR(p, expected_type);
+            CHECK_EXPR(BinaryOperation, expected_type) {
+              CHECK_VAR(start, expected_type);
+              CHECK_EXPR(Literal, expected_type);
+            }
+          }
+          CHECK_EXPR(Assignment, expected_type) {
+            CHECK_VAR(q, expected_type);
+            CHECK_EXPR(BinaryOperation, expected_type) {
+              CHECK_VAR(end, expected_type);
+              CHECK_EXPR(Literal, expected_type);
+            }
+          }
+        }
+        // (p|0) < (q|0);
+        CHECK_EXPR(CompareOperation, expected_type) {
+          CHECK_EXPR(BinaryOperation, expected_type) {
+            CHECK_VAR(p, expected_type);
+            CHECK_EXPR(Literal, expected_type);
+          }
+          CHECK_EXPR(BinaryOperation, expected_type) {
+            CHECK_VAR(q, expected_type);
+            CHECK_EXPR(Literal, expected_type);
+          }
+        }
+        // p = (p + 8)|0) {\n"
+        CHECK_EXPR(Assignment, expected_type) {
+          CHECK_VAR(p, expected_type);
+          CHECK_EXPR(BinaryOperation, expected_type) {
+            CHECK_EXPR(BinaryOperation, expected_type) {
+              CHECK_VAR(p, expected_type);
+              CHECK_EXPR(Literal, expected_type);
+            }
+            CHECK_EXPR(Literal, expected_type);
+          }
+        }
+        // sum = sum + +log(values[p>>3]);
+        CHECK_EXPR(Assignment, expected_type) {
+          CHECK_VAR(sum, expected_type);
+          CHECK_EXPR(BinaryOperation, expected_type) {
+            CHECK_VAR(sum, expected_type);
+            CHECK_EXPR(BinaryOperation, expected_type) {
+              CHECK_EXPR(Call, expected_type) {
+                CHECK_VAR(log, expected_type);
+                CHECK_VAR(values, expected_type);
+                CHECK_EXPR(BinaryOperation, expected_type) {
+                  CHECK_VAR(p, expected_type);
+                  CHECK_EXPR(Literal, expected_type);
+                }
+              }
+              CHECK_EXPR(Literal, expected_type);
+            }
+          }
+        }
+        // return +sum;
+        CHECK_EXPR(BinaryOperation, expected_type) {
+          CHECK_VAR(sum, expected_type);
+          CHECK_EXPR(Literal, expected_type);
+        }
+      }
+      // function geometricMean
+      CHECK_EXPR(FunctionLiteral, expected_type) {
+        CHECK_EXPR(Assignment, expected_type) {
+          CHECK_VAR(start, expected_type);
+          CHECK_EXPR(BinaryOperation, expected_type) {
+            CHECK_VAR(start, expected_type);
+            CHECK_EXPR(Literal, expected_type);
+          }
+        }
+        CHECK_EXPR(Assignment, expected_type) {
+          CHECK_VAR(end, expected_type);
+          CHECK_EXPR(BinaryOperation, expected_type) {
+            CHECK_VAR(end, expected_type);
+            CHECK_EXPR(Literal, expected_type);
+          }
+        }
+        // return +exp(+logSum(start, end) / +((end - start)|0));
+        CHECK_EXPR(BinaryOperation, expected_type) {
+          CHECK_EXPR(Call, expected_type) {
+            CHECK_VAR(exp, expected_type);
+            CHECK_EXPR(BinaryOperation, expected_type) {
+              CHECK_EXPR(BinaryOperation, expected_type) {
+                CHECK_EXPR(Call, expected_type) {
+                  CHECK_VAR(logSum, expected_type);
+                  CHECK_VAR(start, expected_type);
+                  CHECK_VAR(end, expected_type);
+                }
+                CHECK_EXPR(Literal, expected_type);
+              }
+              CHECK_EXPR(BinaryOperation, expected_type) {
+                CHECK_EXPR(BinaryOperation, expected_type) {
+                  CHECK_EXPR(BinaryOperation, expected_type) {
+                    CHECK_VAR(end, expected_type);
+                    CHECK_VAR(start, expected_type);
+                  }
+                  CHECK_EXPR(Literal, expected_type);
+                }
+                CHECK_EXPR(Literal, expected_type);
+              }
+            }
+          }
+          CHECK_EXPR(Literal, expected_type);
+        }
+      }
+      // "use asm";
+      CHECK_EXPR(Literal, expected_type);
+      // var exp = stdlib.Math.exp;
+      CHECK_EXPR(Assignment, expected_type) {
+        CHECK_VAR(exp, expected_type);
+        CHECK_VAR(stdlib, expected_type);
+        CHECK_EXPR(Literal, expected_type);
+        CHECK_EXPR(Literal, expected_type);
+      }
+      // var log = stdlib.Math.log;
+      CHECK_EXPR(Assignment, expected_type) {
+        CHECK_VAR(log, expected_type);
+        CHECK_VAR(stdlib, expected_type);
+        CHECK_EXPR(Literal, expected_type);
+        CHECK_EXPR(Literal, expected_type);
+      }
+      // var values = new stdlib.Float64Array(buffer);
+      CHECK_EXPR(Assignment, expected_type) {
+        CHECK_VAR(values, expected_type);
+        CHECK_EXPR(CallNew, expected_type) {
+          CHECK_VAR(stdlib, expected_type);
+          CHECK_EXPR(Literal, expected_type);
+          CHECK_VAR(buffer, expected_type);
+        }
+      }
+      // return { geometricMean: geometricMean };
+      CHECK_EXPR(ObjectLiteral, expected_type) {
+        CHECK_VAR(geometricMean, expected_type);
+      }
+    }
+  }
+  CHECK_TYPES_END
+}
+}
+
+
+TEST(ResetTypingInfo) {
+  const char test_function[] =
+      "function GeometricMean(stdlib, foreign, buffer) {\n"
+      "  \"use asm\";\n"
+      "\n"
+      "  var exp = stdlib.Math.exp;\n"
+      "  var log = stdlib.Math.log;\n"
+      "  var values = new stdlib.Float64Array(buffer);\n"
+      "\n"
+      "  function logSum(start, end) {\n"
+      "    start = start|0;\n"
+      "    end = end|0;\n"
+      "\n"
+      "    var sum = 0.0, p = 0, q = 0;\n"
+      "\n"
+      "    // asm.js forces byte addressing of the heap by requiring shifting "
+      "by 3\n"
+      "    for (p = start << 3, q = end << 3; (p|0) < (q|0); p = (p + 8)|0) {\n"
+      "      sum = sum + +log(values[p>>3]);\n"
+      "    }\n"
+      "\n"
+      "    return +sum;\n"
+      "  }\n"
+      "\n"
+      " function geometricMean(start, end) {\n"
+      "    start = start|0;\n"
+      "    end = end|0;\n"
+      "\n"
+      "    return +exp(+logSum(start, end) / +((end - start)|0));\n"
+      "  }\n"
+      "\n"
+      "  return { geometricMean: geometricMean };\n"
+      "}\n";
+
+  v8::V8::Initialize();
+  HandleAndZoneScope handles;
+
+  i::Isolate* isolate = CcTest::i_isolate();
+  i::Factory* factory = isolate->factory();
+
+  i::Handle<i::String> source_code =
+      factory->NewStringFromUtf8(i::CStrVector(test_function))
+          .ToHandleChecked();
+
+  i::Handle<i::Script> script = factory->NewScript(source_code);
+
+  i::ParseInfo info(handles.main_zone(), script);
+  i::Parser parser(&info);
+  parser.set_allow_harmony_arrow_functions(true);
+  parser.set_allow_harmony_sloppy(true);
+  info.set_global();
+  info.set_lazy(false);
+  info.set_allow_lazy_parsing(false);
+  info.set_toplevel(true);
+
+  i::CompilationInfo compilation_info(&info);
+  CHECK(i::Compiler::ParseAndAnalyze(&info));
+  info.set_literal(
+      info.scope()->declarations()->at(0)->AsFunctionDeclaration()->fun());
+
+  // Core of the test.
+  ZoneVector<ExpressionTypeEntry> types(handles.main_zone());
+  ExpressionTypeCollector::Run(&compilation_info, &types);
+  CheckAllSame(types, DEFAULT_TYPE);
+
+  TypeSetter::Run(&compilation_info);
+
+  ExpressionTypeCollector::Run(&compilation_info, &types);
+  CheckAllSame(types, INT32_TYPE);
+
+  TypingReseter::Run(&compilation_info);
+
+  ExpressionTypeCollector::Run(&compilation_info, &types);
+  CheckAllSame(types, DEFAULT_TYPE);
+}