[Heavy] Fix Clang environment loading; Fix source-loc

Author: ricejasonf

clang/lib/Parse/ParseDeclHeavy.cpp

@@ -45,11 +45,13 @@ clang::SourceLocation getSourceLocation(heavy::FullSourceLocation Loc) {
      .getLocWithOffset(Loc.getOffset());
 }
 
-void LoadParentEnv(heavy::HeavyScheme& HS, void* Handle) {
+heavy::Environment* LoadEnv(heavy::HeavyScheme& HS, void* Handle) {
   DeclContext* DC = reinterpret_cast<DeclContext*>(Handle);
-  if (!DC->isTranslationUnit()) {
-    HS.LoadEmbeddedEnv(DC->getParent(), LoadParentEnv);
-  }
+  // 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
@@ -154,17 +156,26 @@ bool Parser::ParseHeavyScheme() {
     };
 
     auto expr_eval = [&](heavy::Context& C, heavy::ValueRefs Args) {
-      if (Args.size() != 1) {
-        C.RaiseError("invalid arity to function", C.getCallee());
-        return;
+      heavy::SourceLocation Loc;
+      heavy::Value Input;
+      if (Args.size() == 2) {
+        // Accept any value that may have a source location.
+        Loc = Args[0].getSourceLocation();
+        Input = Args[1];
+      } else if (Args.size() == 1) {
+        Input = Args[0];
+      } else {
+        return C.RaiseError("invalid arity");
       }
-      if (!isa<heavy::String, heavy::Symbol>(Args[0])) {
+      if (!isa<heavy::String, heavy::Symbol>(Input)) {
         C.RaiseError("expecting string or identifier", C.getCallee());
         return;
       }
-      llvm::StringRef Source = Args[0].getStringRef();
-      heavy::SourceLocation Loc = Args[0].getSourceLocation();
-      if (!Loc.isValid()) Loc = C.getLoc();
+      llvm::StringRef Source = Input.getStringRef();
+      if (!Loc.isValid())
+        Loc = Input.getSourceLocation();
+      if (!Loc.isValid())
+        Loc = C.getLoc();
 
       // Prepare to revert Parser.
       TentativeParsingAction ParseReverter(P);
@@ -258,9 +269,11 @@ bool Parser::ParseHeavyScheme() {
           ClangLoc, RequestedFilename->getView(),
           false, nullptr, nullptr, nullptr, nullptr, nullptr,
           nullptr, nullptr, nullptr);
-      if (!File)
-        return C.RaiseError("error opening file",
-                            heavy::Value(RequestedFilename));
+      if (!File) {
+        heavy::String* ErrMsg = C.CreateString("error opening file: ",
+                                            RequestedFilename->getStringRef());
+        return C.RaiseError(ErrMsg, heavy::Value(RequestedFilename));
+      }
       // Determine if file is a system file... as if!
       SrcMgr::CharacteristicKind FileChar = 
         this->PP.getHeaderSearchInfo()
@@ -308,10 +321,6 @@ bool Parser::ParseHeavyScheme() {
 
   PP.InitEmbeddedLexer(LexerInitFn);
 
-  // Load the environment for the current DeclContext
-  DeclContext* DC = getActions().CurContext;
-  HeavyScheme->LoadEmbeddedEnv(DC, LoadParentEnv);
-
   bool HasError = false;
   auto ErrorHandler = [&](llvm::StringRef Err,
                           heavy::FullSourceLocation EmbeddedLoc) {
@@ -356,10 +365,13 @@ 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,
-                                       ErrorHandler,
-                                       Terminator);
+  HeavyScheme->ProcessTopLevelCommands(SchemeLexer, heavy::base::eval,
+                                       ErrorHandler, Env, Terminator);
 
   // Return control to C++ Lexer
   PP.FinishEmbeddedLexer(SchemeLexer.GetByteOffset());

heavy/include/heavy/HeavyScheme.h

@@ -32,6 +32,10 @@ using ModuleLoadNamesFn = void(heavy::Context&);
 using ValueRefs   = llvm::MutableArrayRef<heavy::Value>;
 using ValueFnTy   = void (Context&, ValueRefs);
 
+  namespace base {
+    void eval(Context& C, ValueRefs Args);
+  }
+
 // HeavyScheme - Opaque wrapper for heavy::Context and common operations
 //               needed for embedding scheme
 class HeavyScheme {
@@ -92,8 +96,9 @@ class HeavyScheme {
   //                LoadParent is called, and then the new environment is
   //                created to shadow whatever environment is loaded in
   //                Context at that point.
-  void LoadEmbeddedEnv(void* Handle,
-          llvm::function_ref<void(HeavyScheme&, void*)> LoadParent);
+  using LoadEnvFnTy = heavy::Environment*(HeavyScheme&, void*);
+  heavy::Environment* LoadEmbeddedEnv(void* Handle,
+          llvm::function_ref<LoadEnvFnTy> LoadParent);
 
   using ErrorHandlerFn = void(llvm::StringRef,
                               heavy::FullSourceLocation const&);
@@ -106,12 +111,10 @@ class HeavyScheme {
   //                (ie a heavy::tok::r_paren can terminate without effecting
   //                 the parsing of lists that are delimited by parens)
   //              - ExprHandler defaults to `base::eval`
-  void ProcessTopLevelCommands(heavy::Lexer& Lexer,
-                               llvm::function_ref<ErrorHandlerFn> ErrorHandler,
-                               heavy::tok Terminator);
   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/lib/Builtins.cpp

@@ -41,7 +41,6 @@ heavy::ExternBuiltinSyntax lambda;
 heavy::ExternBuiltinSyntax quasiquote;
 heavy::ExternBuiltinSyntax quote;
 heavy::ExternBuiltinSyntax set;
-heavy::ExternBuiltinSyntax source_loc;
 
 
 heavy::ExternFunction add;
@@ -71,6 +70,7 @@ heavy::ExternFunction raise;
 heavy::ExternFunction error;
 heavy::ExternFunction dynamic_wind;
 heavy::ExternFunction load_module;
+heavy::ExternFunction source_loc;
 
 heavy::ExternFunction eval;
 heavy::ExternFunction op_eval;
@@ -322,17 +322,10 @@ void parse_source_file(Context& C, ValueRefs Args) {
   C.RaiseError("parse-source-file is undefined");
 }
 
-mlir::Value source_loc(OpGen& OG, Pair* P) {
-  // Convert an unevaluated value into a SourceValue.
-  // (or rather the operation to do this).
-  Pair* P2 = dyn_cast<Pair>(P->Cdr);
-  if (!P2 || !isa<Empty>(P2->Cdr)) {
-    return OG.SetError("single argument required", P);
-  }
-  // Defer creating a SourceValue until evaluation.
-  heavy::SourceLocation Loc = P2->Car.getSourceLocation();
-  auto SourceLocOp = OG.create<heavy::SourceLocOp>(Loc);
-  return SourceLocOp.getResult();
+void source_loc(Context& C, ValueRefs Args) {
+  if (Args.size() != 1)
+    return C.RaiseError("expecting single argument");
+  C.Cont(C.CreateSourceValue(Args[0].getSourceLocation()));
 }
 
 } // end of namespace heavy::base

heavy/lib/HeavyScheme.cpp

@@ -26,11 +26,12 @@ namespace heavy {
 
 HeavyScheme::HeavyScheme(std::unique_ptr<heavy::Context> C)
   : ContextPtr(std::move(C)),
-    EnvPtr(std::make_unique<heavy::Environment>(*ContextPtr)),
     SourceManagerPtr(std::make_unique<heavy::SourceManager>()),
     SourceFileStoragePtr(nullptr, [](SourceFileStorage*) { })
 {
-  ContextPtr->setEnvironment(EnvPtr.get());
+  // Create and store the default environment.
+  ContextPtr->EmbeddedEnvs[nullptr] =
+    std::make_unique<heavy::Environment>(*ContextPtr);
 }
 
 HeavyScheme::HeavyScheme()
@@ -53,44 +54,32 @@ heavy::Lexer HeavyScheme::createEmbeddedLexer(uintptr_t ExternalRawLoc,
   return Lexer(File, BufferPos);
 }
 
-void HeavyScheme::LoadEmbeddedEnv(void* Handle,
-          llvm::function_ref<void(HeavyScheme&, void*)> LoadParent) {
-  auto& Context = getContext();
-  auto& EmbeddedEnvs = Context.EmbeddedEnvs; // TODO store EmbeddedEnvs in HeavyScheme
+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()) {
-    Context.EnvStack = itr->second.get();
-    return;
-  }
+  if (itr != EmbeddedEnvs.end())
+    return itr->second.get();
 
-  LoadParent(*this, Handle);
-  Environment* Parent = cast<Environment>(Context.getEnvironment());
-  auto& Env = Context.EmbeddedEnvs[Handle] =
+  assert(Handle != nullptr && "HeavyScheme should have root environment");
+  Environment* Parent = LoadParent(*this, Handle);
+  auto& EnvPtr = EmbeddedEnvs[Handle] =
     std::make_unique<Environment>(Parent);
-  Context.setEnvironment(Env.get());
-  return;
-}
-
-void HeavyScheme::ProcessTopLevelCommands(
-                              heavy::Lexer& Lexer,
-                              llvm::function_ref<ErrorHandlerFn> ErrorHandler,
-                              heavy::tok Terminator) {
-  return ProcessTopLevelCommands(Lexer, base::eval, ErrorHandler,
-                                 Terminator);
+  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) {
-  // This should be the only entry point so that Env is captured and
-  // participates in garbage collection.
-  heavy::Environment* Env = EnvPtr.get();
   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();
 
   auto HandleErrorFn = [&](heavy::Context& Context, ValueRefs Args) {
     heavy::FullSourceLocation FullLoc = SM.getFullSourceLocation(

heavy/lib/SourceFileStorage.cpp

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

heavy/test/Clang/Inputs/my/lib.sld

@@ -0,0 +1,27 @@
+(import (heavy base))
+
+(define-library (my lib)
+  (import (heavy base))
+  (import (heavy clang))
+  (begin
+    (define (lol-trait name)
+      (define loc (source-loc name))
+      (write-lexer loc 'struct)
+      (write-lexer loc
+        (string-append
+          name
+          " { static constexpr bool is_"
+          name
+          " = true; };")))
+    (define (is-empty cpp-typename)
+      (expr-eval
+        (source-loc cpp-typename)
+        (string-append "std::is_empty_v<"
+                       cpp-typename
+                       ">")))
+    (write "end of my lib init")
+    (newline))
+  (export is-empty lol-trait)
+)
+(write "end of my lib module")
+(newline)

heavy/test/Clang/import.cpp

@@ -0,0 +1,33 @@
+// RUN: clang++ -I %S/Inputs -fsyntax-only -Xclang -fheavy -Xclang -verify %s
+
+#include <type_traits>
+
+namespace foo {
+// expected-error@+6{{expected unqualified-id}}
+heavy_scheme {
+(import (my lib))
+(import (heavy base))
+
+(lol-trait 'woof)
+(lol-trait 'my-trait)
+(define hello-foo "hello foo!")
+(write hello-foo)
+}
+}
+
+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"))
+}
+}
+
+static_assert(std::is_empty_v<bar::bark>);
+static_assert(bar::bark::is_bark);