[Heavy] Simplify environments in Clang

Author: ricejasonf

clang/lib/Parse/ParseDeclHeavy.cpp

@@ -45,15 +45,6 @@ clang::SourceLocation getSourceLocation(heavy::FullSourceLocation Loc) {
      .getLocWithOffset(Loc.getOffset());
 }
 
-heavy::Environment* LoadEnv(heavy::HeavyScheme& HS, void* Handle) {
-  DeclContext* DC = reinterpret_cast<DeclContext*>(Handle);
-  // Here, nullptr represents the default, root environment.
-  void* ParentHandle = !DC->isTranslationUnit() ? DC->getParent()
-                                                : nullptr;
-
-  return HS.LoadEmbeddedEnv(ParentHandle, LoadEnv);
-}
-
 // It is complicated to keep the TokenBuffer alive
 // for the Preprocessor, so we use an array to give
 // ownership via the EnterTokenStream overload.
@@ -365,13 +356,9 @@ bool Parser::ParseHeavyScheme() {
     C.Cont();
   }));
 
-  // Get the nested environment for the current DeclContext.
-  DeclContext* DC = getActions().CurContext;
-  heavy::Environment* Env = HeavyScheme->LoadEmbeddedEnv(DC, LoadEnv);
-
   heavy::TokenKind Terminator = heavy::tok::r_brace;
   HeavyScheme->ProcessTopLevelCommands(SchemeLexer, heavy::base::eval,
-                                       ErrorHandler, Env, Terminator);
+                                       ErrorHandler, Terminator);
 
   // Return control to C++ Lexer
   PP.FinishEmbeddedLexer(SchemeLexer.GetByteOffset());

heavy/include/heavy/Context.h

@@ -89,9 +89,11 @@ class Context : public ContinuationStack<Context>,
   static constexpr size_t MiB = 1024 * 1024;
 
   llvm::StringMap<std::unique_ptr<Module>> Modules;
-  llvm::DenseMap<void*, std::unique_ptr<Environment>> EmbeddedEnvs;
   llvm::DenseMap<String*, Value> KnownAddresses;
 
+  // DefaultEnv participates in garbage collection.
+  std::unique_ptr<heavy::Environment> DefaultEnv;
+
   // MaxMemHint
   //         - The threshold used to determine if a garbage
   //           collection run is needed. This value is not a

heavy/include/heavy/HeavyScheme.h

@@ -42,7 +42,6 @@ class HeavyScheme {
   friend class SourceFileStorage;
 
   std::unique_ptr<heavy::Context> ContextPtr;
-  std::unique_ptr<heavy::Environment> EnvPtr;
   std::unique_ptr<heavy::SourceManager> SourceManagerPtr;
   std::unique_ptr<heavy::SourceFileStorage,
                   void(*)(SourceFileStorage*)> SourceFileStoragePtr;
@@ -88,18 +87,6 @@ class HeavyScheme {
   void InitSourceFileStorage();
   void SetModulePath(llvm::StringRef ModulePath);
 
-  // LoadEmbeddedEnv
-  //              - Associates an opaque pointer with a scheme environment
-  //                and loads it as the current environment in the Context.
-  //                Any environment previously loaded with this function is
-  //                cached. If a new environment must be created,
-  //                LoadParent is called, and then the new environment is
-  //                created to shadow whatever environment is loaded in
-  //                Context at that point.
-  using LoadEnvFnTy = heavy::Environment*(HeavyScheme&, void*);
-  heavy::Environment* LoadEmbeddedEnv(void* Handle,
-          llvm::function_ref<LoadEnvFnTy> LoadParent);
-
   using ErrorHandlerFn = void(llvm::StringRef,
                               heavy::FullSourceLocation const&);
 
@@ -114,7 +101,6 @@ class HeavyScheme {
   void ProcessTopLevelCommands(heavy::Lexer& Lexer,
                                llvm::function_ref<ValueFnTy> ExprHandler,
                                llvm::function_ref<ErrorHandlerFn> ErrorHandler,
-                               heavy::Environment* Env = nullptr,
                                heavy::tok Terminator = heavy::tok::eof);
   // ProcessTopLevelCommands
   //              - Filename overload requires calling InitSourceFileStorage.

heavy/include/heavy/Value.h

@@ -1655,18 +1655,16 @@ class Environment : public ValueBase {
   using MapTy = llvm::DenseMap<String*, String*>;
 
   std::unique_ptr<heavy::OpGen> OpGen;
-  Environment* Parent = nullptr;
   MapTy EnvMap;
 
 public:
   // Implemented in Context.cpp
-  Environment(Environment* Parent);
   Environment(heavy::Context& C, heavy::Symbol* ModulePrefix = {});
   ~Environment();
 
-  heavy::OpGen* GetOpGen() {
-    if (OpGen) return OpGen.get();
-    return Parent->GetOpGen();
+  heavy::OpGen* getOpGen() {
+    assert(OpGen && "environment should have OpGen");
+    return OpGen.get();
   }
 
   // Returns nullptr if not found

heavy/lib/Builtins.cpp

@@ -686,7 +686,7 @@ void compile(Context& C, ValueRefs Args) {
   }
 
   // Clear any errors in the compiler too keep the dream alive.
-  if (heavy::OpGen* OpGen = Env->GetOpGen())
+  if (heavy::OpGen* OpGen = Env->getOpGen())
     OpGen->ClearError();
 
   // If there is a provided handler then we save the results in an

heavy/lib/Context.cpp

@@ -92,16 +92,9 @@ bool Context::CheckError() {
   return OpGen && OpGen->CheckError();
 }
 
-Environment::Environment(Environment* Parent)
-  : ValueBase(ValueKind::Environment),
-    OpGen(nullptr),
-    Parent(Parent),
-    EnvMap(0)
-{ }
 Environment::Environment(Context& C, heavy::Symbol* ModulePrefix)
   : ValueBase(ValueKind::Environment),
     OpGen(std::make_unique<heavy::OpGen>(C, ModulePrefix)),
-    Parent(nullptr),
     EnvMap(0)
 { }
 Environment::~Environment() = default;
@@ -1319,7 +1312,7 @@ class LibraryEnv {
                    heavy::Environment* Env,
                    Value Thunk) {
     auto Ptr = std::make_unique<LibraryEnv>(std::move(EnvPtr), Env);
-    heavy::OpGen* OpGen = Ptr->Env->GetOpGen();
+    heavy::OpGen* OpGen = Ptr->Env->getOpGen();
 
     Value PrevEnv = Context.getEnvironment();
     heavy::OpGen* PrevOpGen = Context.OpGen;

heavy/lib/Heap.cpp

@@ -307,8 +307,6 @@ class CopyCollector : private ValueVisitor<CopyCollector, heavy::Value> {
     }
 
     VisitedSpecials.push_back(Env);
-    if (Env->Parent)
-      VisitEnvironment(Env->Parent);
     return Env;
   }
 };
@@ -327,11 +325,8 @@ void Context::CollectGarbage() {
 
   GC.VisitRootNode(EnvStack);
 
-  // EmbeddedEnvs
-  for (auto& DensePair : EmbeddedEnvs) {
-    heavy::Environment* Env = DensePair.second.get(); 
-    GC.VisitEnvironment(Env);
-  }
+  // DefaultEnv is referenced globally.
+  GC.VisitEnvironment(DefaultEnv.get());
 
   // KnownAddresses
   for (auto& DensePair : KnownAddresses) {

heavy/lib/HeavyScheme.cpp

@@ -30,8 +30,7 @@ HeavyScheme::HeavyScheme(std::unique_ptr<heavy::Context> C)
     SourceFileStoragePtr(nullptr, [](SourceFileStorage*) { })
 {
   // Create and store the default environment.
-  ContextPtr->EmbeddedEnvs[nullptr] =
-    std::make_unique<heavy::Environment>(*ContextPtr);
+  ContextPtr->DefaultEnv = std::make_unique<heavy::Environment>(*ContextPtr);
 }
 
 HeavyScheme::HeavyScheme()
@@ -54,32 +53,16 @@ heavy::Lexer HeavyScheme::createEmbeddedLexer(uintptr_t ExternalRawLoc,
   return Lexer(File, BufferPos);
 }
 
-heavy::Environment* HeavyScheme::LoadEmbeddedEnv(void* Handle,
-        llvm::function_ref<heavy::Environment*(HeavyScheme&, void*)> LoadParent) {
-  auto& EmbeddedEnvs = getContext().EmbeddedEnvs;
-  auto itr = EmbeddedEnvs.find(Handle);
-  if (itr != EmbeddedEnvs.end())
-    return itr->second.get();
-
-  assert(Handle != nullptr && "HeavyScheme should have root environment");
-  Environment* Parent = LoadParent(*this, Handle);
-  auto& EnvPtr = EmbeddedEnvs[Handle] =
-    std::make_unique<Environment>(Parent);
-  return EnvPtr.get();
-}
-
 void HeavyScheme::ProcessTopLevelCommands(
                               heavy::Lexer& Lexer,
                               llvm::function_ref<ValueFnTy> ExprHandler,
                               llvm::function_ref<ErrorHandlerFn> ErrorHandler,
-                              heavy::Environment* Env,
                               heavy::tok Terminator) {
   auto& Context = getContext();
   auto& SM = getSourceManager();
   auto ParserPtr = std::make_unique<Parser>(Lexer, Context);
   Parser& Parser = *ParserPtr;
-  if (Env == nullptr)
-    Env = Context.EmbeddedEnvs[nullptr].get();
+  heavy::Environment* Env = Context.DefaultEnv.get();
 
   auto HandleErrorFn = [&](heavy::Context& Context, ValueRefs Args) {
     heavy::FullSourceLocation FullLoc = SM.getFullSourceLocation(

heavy/lib/SourceFileStorage.cpp

@@ -57,8 +57,7 @@ void HeavyScheme::ProcessTopLevelCommands(llvm::StringRef Filename,
     return;
   }
   heavy::Lexer Lexer(FileResult.get());
-  ProcessTopLevelCommands(Lexer, ExprHandler, ErrorHandler,
-                          /*Environment=*/nullptr, tok::eof);
+  ProcessTopLevelCommands(Lexer, ExprHandler, ErrorHandler, tok::eof);
 }
 
 // This overload provides the default file system

heavy/test/Clang/import.cpp

@@ -3,8 +3,9 @@
 #include <type_traits>
 
 namespace foo {
-// expected-error@+6{{expected unqualified-id}}
+// expected-error@+7{{expected unqualified-id}}
 heavy_scheme {
+;// The scheme environment is orthogonal to namespaces.
 (import (my lib))
 (import (heavy base))
 
@@ -19,10 +20,7 @@ static_assert(std::is_empty_v<foo::woof>);
 
 namespace bar {
 heavy_scheme {
-; // FIXME Should we have separate scopes in different namespaces?
-(import (heavy base))
 (write hello-foo)
-(import (my lib)) ; FIXME
 (if (is-empty 'foo::woof)
   (lol-trait 'bark)
   (raise-error "expecting empty woof"))