[Heavy] Improve syntax closures and lookup

Author: ricejasonf

heavy/include/heavy/Context.h

@@ -108,6 +108,7 @@ class Context : public ContinuationStack<Context>,
   //  - an improper list ending with an Environment
   //  - Calls to procedures or eval will set the EnvStack
   //    and swap it back upon completion (via RAII)
+  //  - TODO EnvStack et al. could probably be moved to OpGen.
   Value EnvStack;
 
 public: // Provide access in lib/Mlir bindings.
@@ -173,7 +174,7 @@ class Context : public ContinuationStack<Context>,
     return EnvStack;
   }
   void setEnvironment(Value E) {
-    assert((isa<Environment, Pair, Empty>(E)) &&
+    assert((isa<Environment, Pair, EnvFrame, Empty>(E)) &&
         "invalid environment specifier");
     EnvStack = E;
   }
@@ -213,25 +214,26 @@ class Context : public ContinuationStack<Context>,
   // Lookup
   //  - Takes a Symbol
   //  - Returns a matching Binder or nullptr
-  EnvEntry Lookup(Symbol* Name, Value Stack);
-  EnvEntry Lookup(Symbol* Name) {
-    return Lookup(Name, EnvStack);
+  EnvEntry Lookup(Value Id) {
+    return Lookup(Id, EnvStack);
   }
+  EnvEntry Lookup(Value Id, Value Stack);
 
   // PushEnvFrame - Creates and pushes an EnvFrame to the
   //                current environment (EnvStack)
-  EnvFrame* PushEnvFrame(llvm::ArrayRef<Symbol*> Names);
+  EnvFrame* PushEnvFrame(llvm::ArrayRef<Value> Names);
   void PopEnvFrame();
   void PushLocalBinding(Binding* B);
 
-  // PushLambdaFormals - Checks formals, creates an EnvFrame,
-  //                     and pushes it onto the EnvStack
-  //                     Returns the pushed EnvFrame or nullptr
-  EnvFrame* PushLambdaFormals(Value Formals, bool& HasRestParam);
+  // PushLambdaFormals - Check formals, create an EnvFrame,
+  //                     and push it onto the EnvStack
+  //                     Return the pushed EnvFrame or nullptr.
+  EnvFrame* PushLambdaFormals(Value Formals, bool& HasRestParam,
+                              SyntaxClosure* SC);
 private:
   bool CheckLambdaFormals(Value Formals,
-                          llvm::SmallVectorImpl<Symbol*>& Names,
-                          bool& HasRestParam);
+                          llvm::SmallVectorImpl<Value>& Names,
+                          bool& HasRestParam, SyntaxClosure* SC);
 public:
 
   void EmitStackSpaceError();
@@ -340,7 +342,8 @@ class Context : public ContinuationStack<Context>,
   Vector*     CreateVector(ArrayRef<Value> Xs);
   Vector*     CreateVector(unsigned N);
   ByteVector* CreateByteVector(llvm::ArrayRef<Value> Xs);
-  EnvFrame*   CreateEnvFrame(llvm::ArrayRef<Symbol*> Names);
+  EnvFrame*   CreateEnvFrame(llvm::ArrayRef<Value> Names);
+  EnvFrame*   CreateEnvFrame(unsigned N);
 
   template <typename T>
   Any* CreateAny(T Obj) {
@@ -387,8 +390,9 @@ class Context : public ContinuationStack<Context>,
     return new (*this) BuiltinSyntax(Fn);
   }
 
-  SyntaxClosure* CreateSyntaxClosure(SourceLocation Loc, Value Node) {
-    return new (*this) SyntaxClosure(Loc, EnvStack, Node);
+  SyntaxClosure* CreateSyntaxClosure(SourceLocation Loc, Value Node,
+                                     Value Env) {
+    return new (*this) SyntaxClosure(Loc, Env, Node);
   }
 
   SourceValue* CreateSourceValue(SourceLocation Loc) {
@@ -415,8 +419,8 @@ class Context : public ContinuationStack<Context>,
     return new (*this) Exception(V);
   }
 
-  Binding* CreateBinding(Symbol* S, Value V) {
-    return new (*this) Binding(S, V);
+  Binding* CreateBinding(Value Id, Value V) {
+    return new (*this) Binding(Id, V);
   }
 
   // CreateImportSet - Call CC with created ImportSet.

heavy/include/heavy/OpGen.h

@@ -34,6 +34,7 @@ namespace mlir {
 }
 
 namespace heavy {
+using IdSet = std::set<std::pair<uintptr_t, uintptr_t>>;
 using NameSet = llvm::SmallPtrSetImpl<String*>;
 class PatternTemplate;
 class TemplateGen;
@@ -118,6 +119,10 @@ class OpGen : public ValueVisitor<OpGen, mlir::Value> {
   //                  be inserted if this is set.
   Binding* LibraryEnvProc = nullptr;
 
+  // The current syntax closure will affect how we perform lookup
+  // in LookupEnv.
+  SyntaxClosure* CurSyntaxClosure = nullptr;
+
   // Err - The stored error to indicate that the compiler is in an error state.
   //       (Use CheckError())
   Value Err = nullptr;
@@ -146,7 +151,7 @@ class OpGen : public ValueVisitor<OpGen, mlir::Value> {
   };
 
   void InsertTopLevelCommandOp(SourceLocation Loc);
-  bool WalkDefineInits(Value Env, NameSet& LocalNames);
+  bool WalkDefineInits(Value Env, IdSet& LocalNames);
   bool FinishLocalDefines();
 
 public:
@@ -266,7 +271,8 @@ class OpGen : public ValueVisitor<OpGen, mlir::Value> {
 
   mlir::Value createCall(heavy::SourceLocation Loc, mlir::Value Fn,
                          llvm::MutableArrayRef<mlir::Value> Args);
-  mlir::Value createOpGen(SourceLocation Loc, mlir::Value Input);
+  mlir::Value createOpGen(SourceLocation Loc, mlir::Value Input,
+                          mlir::Value Env);
   mlir::Value createBody(SourceLocation Loc, Value Body);
   mlir::Value createSequence(SourceLocation Loc, Value Body);
   mlir::Value createSyntaxSpec(Pair* SyntaxSpec, Value OrigCall);
@@ -377,10 +383,13 @@ class OpGen : public ValueVisitor<OpGen, mlir::Value> {
   }
 
   mlir::Operation* LookupSymbol(llvm::StringRef MangledName);
+
+  heavy::EnvEntry LookupEnv(heavy::Value Id);
 private:
-  mlir::Value MaybeCallSyntax(Pair* P, bool& DidCallSyntax);
+  mlir::Value MaybeCallSyntax(Pair* P, bool& DidCallSyntax,
+                              heavy::EnvEntry& FnEnvEntry);
   mlir::Value MaybeCallSyntax(Value Operator, Pair* P, bool& DidCallSyntax);
-  mlir::Value HandleCall(Pair* P);
+  mlir::Value HandleCall(Pair* P, heavy::EnvEntry FnEnvEntry);
 };
 
 }

heavy/include/heavy/Ops.td

@@ -177,7 +177,7 @@ def heavy_OpGenOp : HeavyOp<"opgen", [Terminator]> {
     This operation is used for syntax code generation.
   }];
 
-  let arguments = (ins HeavyValue:$input);
+  let arguments = (ins HeavyValue:$input, HeavyValue:$env);
   let results   = (outs);
 }
 
@@ -444,7 +444,7 @@ def heavy_ResolveOp : HeavyOp<"resolve", [Terminator]> {
 def heavy_PatternOp : HeavyOp<"pattern", [HasParent<"SyntaxOp">]> {
   let description = [{
     PatternOp represents the pattern in a pattern/template
-    pair as part of the syntax-rules transform specifier. The 
+    pair as part of the syntax-rules transform specifier. The
     region should contain matching operations on the input syntax,
     as well as ConsOps for the template, terminating with an OpGenOp
     on the constructed AST.
@@ -471,16 +471,38 @@ def heavy_PushContOp : HeavyOp<"push_cont", []> {
 def heavy_RenameOp : HeavyOp<"rename", [HasParent<"PatternOp">]> {
   let summary = "rename";
   let description = [{
-    "Rename" a local variable by storing an opaque representation
-    of its mlir::Value. The lifetime of this value expires with the
-    MLIR Context so compilation of these operations should only be JIT.
-    (Local syntax can never be exported)
+    Capture a value and "rename" it using an identifier to use in the
+    scope of a syntax object. These lookups can be shadowed by the
+    environment created during template expansion (as I understand it.)
+
+    The $capture mlir::Value which may belong to a parent scope is
+    used to generate a localized value in the context of the template
+    expansion.
   }];
 
-  let arguments = (ins UI64Attr:$opaqueValue);
+  let arguments = (ins StrAttr:$id, HeavyValue:$capture);
   let results   = (outs HeavyValue:$result);
-  let builders  = [
-    OpBuilder<(ins "::mlir::Value":$opaqueValue)>
+  let builders = [
+    OpBuilder<(ins "::llvm::StringRef":$id, "::mlir::Value":$capture)>
+  ];
+}
+
+def heavy_RenameGlobalOp : HeavyOp<"rename_global", [HasParent<"PatternOp">]> {
+  let summary = "rename_global";
+  let description = [{
+    Similar to RenameOp, this RenameGlobalOp represents the possibility of
+    expanding the use of a global by generating a LoadGlobalOp in the context
+    of the template expansion.
+
+    Because globals can be defined lazily within the module, it is possible
+    that this operation could be generated when no global of the corresponding
+    name was defined. In this case the RenameOp can be removed.
+  }];
+
+  let arguments = (ins StrAttr:$id, StrAttr:$sym);
+  let results   = (outs HeavyValue:$result);
+  let builders = [
+    OpBuilder<(ins "::llvm::StringRef":$id, "::llvm::StringRef":$sym)>
   ];
 }
 
@@ -531,15 +553,15 @@ def heavy_SpliceOp : HeavyOp<"splice"> {
 def heavy_SyntaxClosureOp : HeavyOp<"syntax_closure"> {
   let summary = "syntax_closure";
   let description = [{
-    SyntaxClosureOp captures a syntax node with the current
+    SyntaxClosureOp captures a syntax node with the given
     environment. This supports generating code during hygienic
     macro expansion.
   }];
 
-  let arguments = (ins HeavyValue:$input);
+  let arguments = (ins HeavyValue:$input, HeavyValue:$env);
   let results   = (outs HeavyValue:$result);
   let builders  = [
-    OpBuilder<(ins "::mlir::Value":$input)>
+    OpBuilder<(ins "::mlir::Value":$input, "::mlir::Value":$env)>
   ];
 }
 
@@ -589,6 +611,22 @@ def heavy_VectorOp : HeavyOp<"vector"> {
   ];
 }
 
+def heavy_EnvFrameOp : HeavyOp<"env_frame"> {
+  let description = [{
+    EnvFrameOp creates a vector-like object of bindings.
+
+    Since it serves to define lexical scopes in the
+    environment, it exists apart from VectorOp so that
+    the bindings do not get unwrapped during evaluation.
+  }];
+
+  let arguments = (ins Variadic<HeavyValue>:$args);
+  let results   = (outs HeavyValue: $result);
+  let builders = [
+    OpBuilder<(ins "::llvm::ArrayRef<::mlir::Value>":$args)>
+  ];
+}
+
 def heavy_UndefinedOp : HeavyOp<"undefined", [Pure]> {
   let summary = "undefined";
   let description = [{