cctest: put some types into anonymous namespace.

test/cctest/test-decls.cc

 // Copyright 2007-2008 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 16 matching lines @@
 
 #include <stdlib.h>
 
 #include "src/v8.h"
 
 #include "src/heap/heap.h"
 #include "test/cctest/cctest.h"
 
 using namespace v8;
 
-
-enum Expectations {
+// TODO(krasin): rename this type back to Expectations when
+// https://crbug.com/630335 is fixed. Clang confuses two Expectations
+// types: here and in test-field-type-tracking.cc, which makes the

[Benedikt Meurer, 2016/08/10 08:09:33]

How about just using an anonymous namespace?

[krasin, 2016/08/10 16:19:34]

Done.

+// official Chrome build flaky.
+enum ExpectationsCode {
   EXPECT_RESULT,
   EXPECT_EXCEPTION,
   EXPECT_ERROR
 };
 
 
 // A DeclarationContext holds a reference to a v8::Context and keeps
 // track of various declaration related counters to make it easier to
 // track if global declarations in the presence of interceptors behave
 // the right way.
 class DeclarationContext {
  public:
   DeclarationContext();
 
   virtual ~DeclarationContext() {
     if (is_initialized_) {
       Isolate* isolate = CcTest::isolate();
       HandleScope scope(isolate);
       Local<Context> context = Local<Context>::New(isolate, context_);
       context->Exit();
       context_.Reset();
     }
   }
 
   void Check(const char* source, int get, int set, int has,
-             Expectations expectations,
+             ExpectationsCode expectations,
              v8::Local<Value> value = Local<Value>());
 
   int get_count() const { return get_count_; }
   int set_count() const { return set_count_; }
   int query_count() const { return query_count_; }
 
  protected:
   virtual v8::Local<Value> Get(Local<Name> key);
   virtual v8::Local<Value> Set(Local<Name> key, Local<Value> value);
   virtual v8::Local<Integer> Query(Local<Name> key);
@@ skipping 56 matching lines @@
   is_initialized_ = true;
   // Reset counts. Bootstrapping might have called into the interceptor.
   get_count_ = 0;
   set_count_ = 0;
   query_count_ = 0;
   PostInitializeContext(context);
 }
 
 
 void DeclarationContext::Check(const char* source, int get, int set, int query,
-                               Expectations expectations,
+                               ExpectationsCode expectations,
                                v8::Local<Value> value) {
   InitializeIfNeeded();
   // A retry after a GC may pollute the counts, so perform gc now
   // to avoid that.
   CcTest::heap()->CollectGarbage(v8::internal::NEW_SPACE);
   HandleScope scope(CcTest::isolate());
   TryCatch catcher(CcTest::isolate());
   catcher.SetVerbose(true);
   Local<Context> context = CcTest::isolate()->GetCurrentContext();
   MaybeLocal<Script> script = Script::Compile(
@@ skipping 346 matching lines @@
   SimpleContext()
       : handle_scope_(CcTest::isolate()),
         context_(Context::New(CcTest::isolate())) {
     context_->Enter();
   }
 
   ~SimpleContext() {
     context_->Exit();
   }
 
-  void Check(const char* source, Expectations expectations,
+  void Check(const char* source, ExpectationsCode expectations,
              v8::Local<Value> value = Local<Value>()) {
     HandleScope scope(context_->GetIsolate());
     TryCatch catcher(context_->GetIsolate());
     catcher.SetVerbose(true);
     MaybeLocal<Script> script = Script::Compile(
         context_, String::NewFromUtf8(context_->GetIsolate(), source,
                                       v8::NewStringType::kNormal)
                       .ToLocalChecked());
     if (expectations == EXPECT_ERROR) {
       CHECK(script.IsEmpty());
@@ skipping 655 matching lines @@
                   Undefined(CcTest::isolate()));
     for (int i = 0; i < 4; i++) {
       context.Check("f()", EXPECT_EXCEPTION);
     }
     context.Check("%OptimizeFunctionOnNextCall(f);", EXPECT_RESULT,
                   Undefined(CcTest::isolate()));
 
     context.Check("'use strict'; f(); let x = 2; x", EXPECT_EXCEPTION);
   }
 }