[Heavy] Update to Clang22

ricejasonf · ricejasonf · commit 16688e9a2a3b · 2025-12-02T12:00:24.000-08:00
diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
@@ -37,7 +37,6 @@
      LANGOPT(Name, Bits, Default, Compatibility, Description)
 #endif
 
-<<<<<<< HEAD
 // FIXME: A lot of the Benign options should be Compatible instead.
 LANGOPT(C99               , 1, 0, NotCompatible, "C99")
 LANGOPT(C11               , 1, 0, NotCompatible, "C11")
@@ -88,7 +87,7 @@ LANGOPT(AppleKext         , 1, 0, NotCompatible, "Apple kext support")
 LANGOPT(PascalStrings     , 1, 0, Benign, "Pascal string support")
 LANGOPT(WritableStrings   , 1, 0, NotCompatible, "writable string support")
 LANGOPT(ConstStrings      , 1, 0, NotCompatible, "const-qualified string support")
-LANGOPT(Heavy             , 1, 0, "Heavy")
+LANGOPT(Heavy             , 1, 0, NotCompatible, "Heavy scheme integration")
 ENUM_LANGOPT(LaxVectorConversions, LaxVectorConversionKind, 2,
              LaxVectorConversionKind::All, NotCompatible, "lax vector conversions")
 ENUM_LANGOPT(AltivecSrcCompat, AltivecSrcCompatKind, 2,
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
@@ -7051,7 +7051,7 @@ class Parser : public CodeCompletionHandler {
   std::unique_ptr<PragmaHandler> MaxTokensHerePragmaHandler;
   std::unique_ptr<PragmaHandler> MaxTokensTotalPragmaHandler;
   std::unique_ptr<PragmaHandler> RISCVPragmaHandler;
-  std::unique_ptr<heavy::Context> HeavySchemeContext;
+  std::unique_ptr<heavy::HeavyScheme> HeavyScheme;
 
   /// Initialize all pragma handlers.
   void initializePragmaHandlers();
diff --git a/clang/lib/Lex/Preprocessor.cpp b/clang/lib/Lex/Preprocessor.cpp
@@ -1716,17 +1716,6 @@ void NoTrivialPPDirectiveTracer::MacroExpands(const Token &MacroNameTok,
     setSeenNoTrivialPPDirective();
 }
 
-void Preprocessor::InitHeavySchemeLexer() {
-  if (!TheHeavySchemeLexer) {
-    TheHeavySchemeLexer = std::unique_ptr<HeavySchemeLexer>(
-        new HeavySchemeLexer(*this));
-  }
-  TheHeavySchemeLexer->Init(CurLexer->getFileLoc(),
-                            CurLexer->BufferStart,
-                            CurLexer->BufferEnd,
-                            CurLexer->BufferPtr);
-}
-
 void Preprocessor::InitEmbeddedLexer(
           llvm::function_ref<EmbeddedLexerInitFn> InitFn) {
   assert(IsFileLexer() && "cannot embed scheme in macro expansion");
diff --git a/heavy/include/heavy/ContinuationStack.h b/heavy/include/heavy/ContinuationStack.h
@@ -165,7 +165,7 @@ class ContinuationStack {
     if (Src.getDepth() < Dest.getDepth()) {
       C.PushCont([](Derived& C, ValueRefs) {
         DWind Dest = C.getCapture(0);
-        C.Apply(Dest.getBeforeFn(), std::nullopt);
+        C.ApplyThunk(Value(Dest.getBeforeFn()));
       }, CaptureList{Dest});
       C.TraverseWindings(Src, Dest.getParent());
     } else {
@@ -174,7 +174,7 @@ class ContinuationStack {
         DWind Dest = C.getCapture(1);
         C.TraverseWindings(Src.getParent(), Dest);
       }, CaptureList{Src, Dest});
-      C.Apply(Src.getAfterFn(), std::nullopt);
+      C.ApplyThunk(Value(Src.getAfterFn()));
     }
   }
 
diff --git a/heavy/include/heavy/OpGen.h b/heavy/include/heavy/OpGen.h
@@ -243,7 +243,7 @@ class OpGen : public ValueVisitor<OpGen, mlir::Value> {
         "Operation must have insertion point");
     mlir::Location MLoc = mlir::OpaqueLoc::get(Loc.getOpaqueEncoding(),
                                                Builder.getContext());
-    return Builder.create<Op>(MLoc, std::forward<Args>(args)...);
+    return Op::create(Builder, MLoc, std::forward<Args>(args)...);
   }
 
   template <typename Op, typename ...Args>
diff --git a/heavy/include/heavy/Ops.td b/heavy/include/heavy/Ops.td
@@ -156,7 +156,7 @@ def heavy_ExpandPacksOp : HeavyOp<"expand_packs", []> {
   let builders = [
     OpBuilder<(ins "::mlir::Value":$cdr,
                    "::mlir::ValueRange":$packs,
-                   "std::unique_ptr<::mlir::Region>":$body)>
+                   "std::unique_ptr<::mlir::Region>&&":$body)>
   ];
 }
 
@@ -370,10 +370,6 @@ def heavy_MatchIdOp : HeavyOp<"match-id", []> {
 
   let arguments = (ins HeavyValue:$val, HeavyValue:$input);
   let results   = (outs);
-
-  let builders = [
-    OpBuilder<(ins "::heavy::Value":$val, "::mlir::Value":$input)>
-  ];
 }
 
 def heavy_MatchPairOp : HeavyOp<"match_pair", []> {
@@ -484,7 +480,7 @@ def heavy_SubpatternOp : HeavyOp<"subpattern", []> {
   let builders = [
     OpBuilder<(ins "::mlir::Value":$input,
                    "::mlir::Value":$tail,
-                   "std::unique_ptr<::mlir::Region>":$body,
+                   "std::unique_ptr<::mlir::Region>&&":$body,
                    "unsigned":$num_packs)>
   ];
 }
diff --git a/heavy/include/heavy/Value.h b/heavy/include/heavy/Value.h
@@ -234,7 +234,7 @@ struct StatelessPointerTraitBase {
 
   // all the bits??
   static constexpr int NumLowBitsAvailable =
-      llvm::detail::ConstantLog2<alignof(void*)>::value;
+      llvm::ConstantLog2<alignof(void*)>();
 };
 }}
 
@@ -292,7 +292,7 @@ struct ValueSumType {
     }
 
     static constexpr int NumLowBitsAvailable =
-      llvm::detail::ConstantLog2<alignof(void*)>::value;
+      llvm::ConstantLog2<alignof(void*)>();
   };
 
   struct ContArgTraits {
@@ -304,7 +304,7 @@ struct ValueSumType {
     }
 
     static constexpr int NumLowBitsAvailable =
-      llvm::detail::ConstantLog2<alignof(void*)>::value;
+      llvm::ConstantLog2<alignof(void*)>();
   };
 
   using type = llvm::PointerSumType<SumKind,
@@ -866,18 +866,18 @@ class String final
     : ValueBase(ValueKind::String),
       Len(Length)
   {
-    std::memset(getTrailingObjects<char>(), InitChar, Len);
+    std::memset(getTrailingObjects(), InitChar, Len);
     // Set trailing null byte.
-    *(getTrailingObjects<char>() + Len) = '\0';
+    *(getTrailingObjects() + Len) = '\0';
   }
 
   String(llvm::StringRef S)
     : ValueBase(ValueKind::String),
       Len(S.size())
   {
-    std::memcpy(getTrailingObjects<char>(), S.data(), S.size());
+    std::memcpy(getTrailingObjects(), S.data(), S.size());
     // Set trailing null byte.
-    *(getTrailingObjects<char>() + Len) = '\0';
+    *(getTrailingObjects() + Len) = '\0';
   }
 
   template <typename ...StringRefs>
@@ -886,13 +886,13 @@ class String final
       Len(TotalLen)
   {
     std::array<llvm::StringRef, sizeof...(Ss)> Arr = {Ss...};
-    char* StrData = getTrailingObjects<char>();
+    char* StrData = getTrailingObjects();
     for (llvm::StringRef S : Arr) {
       std::memcpy(StrData, S.data(), S.size());
       StrData += S.size();
     }
     // Set trailing null byte.
-    *(getTrailingObjects<char>() + Len) = '\0';
+    *(getTrailingObjects() + Len) = '\0';
   }
 
   static constexpr size_t sizeToAlloc(unsigned Length) {
@@ -903,11 +903,11 @@ class String final
   unsigned size() const { return Len; }
 
   llvm::StringRef getView() const {
-    return llvm::StringRef(getTrailingObjects<char>(), Len);
+    return llvm::StringRef(getTrailingObjects(), Len);
   }
 
   llvm::MutableArrayRef<char> getMutableView() {
-    return llvm::MutableArrayRef(getTrailingObjects<char>(), Len);
+    return llvm::MutableArrayRef(getTrailingObjects(), Len);
   }
 
   bool Equiv(String* S) const {
@@ -1202,7 +1202,7 @@ class Syntax final
   OpaqueFnPtrTy FnPtr;
   unsigned StorageLen;
 
-  void* getStoragePtr() { return getTrailingObjects<char>(); }
+  void* getStoragePtr() { return getTrailingObjects(); }
 
 public:
   Syntax(OpaqueFn FnData)
@@ -1302,15 +1302,15 @@ class Vector final
     : ValueBase(ValueKind::Vector),
       Len(Vs.size())
   {
-    std::memcpy(getTrailingObjects<Value>(), Vs.data(),
+    std::memcpy(getTrailingObjects(), Vs.data(),
                 Len * sizeof(Value));
   }
 
   Vector(Value V, unsigned N)
     : ValueBase(ValueKind::Vector),
       Len(N)
   {
-    Value* Xs = getTrailingObjects<Value>();
+    Value* Xs = getTrailingObjects();
     for (unsigned i = 0; i < Len; ++i) {
       Xs[i] = V;
     }
@@ -1333,17 +1333,17 @@ class Vector final
 
   Value& get(unsigned I) {
     assert(I < Len && "invalid index for vector");
-    return *(getTrailingObjects<Value>() + I);
+    return *(getTrailingObjects() + I);
   }
 
   llvm::ArrayRef<Value> getElements() const {
     return llvm::ArrayRef<Value>(
-        getTrailingObjects<Value>(), Len);
+        getTrailingObjects(), Len);
   }
 
   llvm::MutableArrayRef<Value> getElements() {
     return llvm::MutableArrayRef<Value>(
-        getTrailingObjects<Value>(), Len);
+        getTrailingObjects(), Len);
   }
 
   static bool classof(Value V) {
@@ -1398,7 +1398,7 @@ class Any final :
   }
 
   // Note that for stored pointers, this will return a pointer to a pointer.
-  void* getOpaquePtr() { return getTrailingObjects<char>(); }
+  void* getOpaquePtr() { return getTrailingObjects(); }
 
   llvm::StringRef getObjData() {
     return llvm::StringRef(static_cast<char*>(getOpaquePtr()), getObjectSize());
@@ -1556,12 +1556,12 @@ class EnvFrame final
 
   llvm::ArrayRef<Binding*> getBindings() const {
     return llvm::ArrayRef<Binding*>(
-        getTrailingObjects<Binding*>(), NumBindings);
+        getTrailingObjects(), NumBindings);
   }
 
   llvm::MutableArrayRef<Binding*> getBindings() {
     return llvm::MutableArrayRef<Binding*>(
-        getTrailingObjects<Binding*>(), NumBindings);
+        getTrailingObjects(), NumBindings);
   }
 
   Value getLocalStack() const { return LocalStack; }
diff --git a/heavy/include/nbdl_gen/Nbdl.td b/heavy/include/nbdl_gen/Nbdl.td
@@ -425,7 +425,7 @@ def Nbdl_ScopeOp : Nbdl_Op<"scope", []> {
   let regions = (region SizedRegion<1>:$body);
 
   let builders = [
-    OpBuilder<(ins "std::unique_ptr<::mlir::Region>":$body)>
+    OpBuilder<(ins "std::unique_ptr<::mlir::Region>&&":$body)>
   ];
 }
 
diff --git a/heavy/lib/Dialect.cpp b/heavy/lib/Dialect.cpp
@@ -198,9 +198,19 @@ void MatchArgsOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
   MatchArgsOp::build(B, OpState, ResultTypes, Input);
 }
 
+void MatchVectorOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
+                          uint32_t Head, uint32_t Tail, mlir::Value Input) {
+  llvm_unreachable("FIXME This is all very untested.");
+  assert(Tail >= Head);
+  unsigned NumResults = Tail - Head;
+  mlir::Type HeavyValueT = B.getType<HeavyValueTy>();
+  llvm::SmallVector<mlir::Type, 4> ResultTypes(NumResults, HeavyValueT);
+  MatchVectorOp::build(B, OpState, ResultTypes, Head, Tail, Input);
+}
+
 void SubpatternOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
                         mlir::Value Input, mlir::Value Tail,
-                        std::unique_ptr<mlir::Region> Body,
+                        std::unique_ptr<mlir::Region>&& Body,
                         unsigned NumPacks) {
   mlir::Type HeavyValueT = B.getType<HeavyValueTy>();
   llvm::SmallVector<mlir::Type, 4> ResultTypes(NumPacks, HeavyValueT);
@@ -211,7 +221,7 @@ void SubpatternOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
 
 void ExpandPacksOp::build(mlir::OpBuilder& B, mlir::OperationState& OpState,
                         mlir::Value Cdr, mlir::ValueRange Packs,
-                        std::unique_ptr<mlir::Region> Body) {
+                        std::unique_ptr<mlir::Region>&& Body) {
   mlir::Type HeavyValueT = B.getType<HeavyValueTy>();
   OpState.addOperands(Cdr);
   OpState.addOperands(Packs);
diff --git a/heavy/lib/Nbdl.cpp b/heavy/lib/Nbdl.cpp
@@ -102,7 +102,7 @@ void build_match_params_impl(Context& C, ValueRefs Args) {
                                                   /*ResultTypes*/{});
 
   // Create the function.
-  auto FuncOp = Builder.create<mlir::func::FuncOp>(MLoc, Name, FT);
+  auto FuncOp = mlir::func::FuncOp::create(Builder, MLoc, Name, FT);
   FuncOp.addEntryBlock();
 
   heavy::Value Thunk = C.CreateLambda([FuncOp](Context& C, ValueRefs) mutable {
@@ -147,7 +147,7 @@ void build_overload_impl(Context& C, ValueRefs Args) {
   llvm::StringRef Typename = TypenameArg.getStringRef();
   mlir::Location MLoc = mlir::OpaqueLoc::get(Loc.getOpaqueEncoding(),
                                              Builder->getContext());
-  auto OverloadOp = Builder->create<nbdl_gen::OverloadOp>(MLoc, Typename);
+  auto OverloadOp = nbdl_gen::OverloadOp::create(*Builder, MLoc, Typename);
   if (!Callback)
     return C.Cont();
 
@@ -191,7 +191,7 @@ void build_match_if_impl(Context& C, ValueRefs Args) {
 
   mlir::Location MLoc = mlir::OpaqueLoc::get(Loc.getOpaqueEncoding(),
                                              Builder->getContext());
-  auto MatchIfOp = Builder->create<nbdl_gen::MatchIfOp>(MLoc, Input, Pred);
+  auto MatchIfOp = nbdl_gen::MatchIfOp::create(*Builder, MLoc, Input, Pred);
   MatchIfOp.getThenRegion().emplaceBlock();
   MatchIfOp.getElseRegion().emplaceBlock();
 
@@ -278,7 +278,8 @@ void close_previous_scope(Context& C, ValueRefs Args) {
   mlir::Block& NewBlock = ScopeBody->emplaceBlock();
   while (!Block->empty())
     Block->front().moveBefore(&NewBlock, NewBlock.end());
-  mlir::Operation* ScopeOp = Builder->create<nbdl_gen::ScopeOp>(Loc, std::move(ScopeBody));
+  mlir::Operation* ScopeOp = nbdl_gen::ScopeOp::create(
+                              *Builder, Loc, std::move(ScopeBody));
   Builder->setInsertionPointAfter(ScopeOp);
 
   C.Cont();
@@ -358,7 +359,7 @@ void HEAVY_NBDL_INIT(heavy::Context& C) {
   mlir::OpBuilder Builder(C.MLIRContext.get());
   mlir::Location Loc = Builder.getUnknownLoc();
   mlir::ModuleOp ModuleOp
-    = Builder.create<mlir::ModuleOp>(Loc, "nbdl_gen_module");
+    = mlir::ModuleOp::create(Builder, Loc, "nbdl_gen_module");
 
   heavy::nbdl_bind_var::current_nbdl_module.set(C, ModuleOp.getOperation());
   heavy::nbdl_bind_var::translate_cpp = heavy::nbdl_bind::translate_cpp;
diff --git a/heavy/lib/Nbdl/NbdlDialect.cpp b/heavy/lib/Nbdl/NbdlDialect.cpp
@@ -44,6 +44,6 @@ void nbdl_gen::NbdlDialect::initialize() {
 
 void nbdl_gen::ScopeOp::build(::mlir::OpBuilder&,
                               ::mlir::OperationState& odsState,
-                              std::unique_ptr<::mlir::Region> body) {
+                              std::unique_ptr<::mlir::Region>&& body) {
   odsState.addRegion(std::move(body));
 }
diff --git a/heavy/lib/OpGen.cpp b/heavy/lib/OpGen.cpp
@@ -97,16 +97,16 @@ OpGen::OpGen(heavy::Context& C, heavy::Symbol* ModulePrefix)
     assert(!C.ModuleOp && "There should be only one top level module");
     C.MLIRContext->loadDialect<heavy::Dialect, mlir::func::FuncDialect>();
     // Create the module that contains the main module and import modules
-    TopModule = Builder.create<mlir::ModuleOp>(Loc);
+    TopModule = mlir::ModuleOp::create(Builder, Loc);
     C.ModuleOp = TopModule;
     // The first child ModuleOp is the main module. All subsequent
     // modules are imports.
   } else {
     TopModule = cast<mlir::ModuleOp>(C.ModuleOp);
   }
   ImportsBuilder.setInsertionPointToEnd(TopModule.getBody());
-  ModuleOp = ImportsBuilder.create<mlir::ModuleOp>(Loc,
-                                        getModulePrefix());
+  ModuleOp = mlir::ModuleOp::create(ImportsBuilder, Loc,
+                                    getModulePrefix());
 
   ModuleBuilder.setInsertionPointToStart(
       cast<mlir::ModuleOp>(ModuleOp).getBody());
@@ -590,7 +590,7 @@ mlir::Value OpGen::createLambdaBody(SourceLocation Loc,
       if (IsLocalDefineAllowed)
         FinishLocalDefines();
       Result = LocalizeValue(Result);
-      Builder.create<ContOp>(Result.getLoc(), Result);
+      ContOp::create(Builder, Result.getLoc(), Result);
     }
 
     Context.PopEnvFrame(EnvFrame);
@@ -676,7 +676,7 @@ void OpGen::PopContinuationScope() {
                                   .getValue();
   assert(LS.CallOp != nullptr && "a PushContOp should precede a call");
   Builder.setInsertionPoint(LS.CallOp);
-  Builder.create<PushContOp>(Loc, MangledName, LS.Captures);
+  PushContOp::create(Builder, Loc, MangledName, LS.Captures);
   LambdaScopes.pop_back();
 }
 
@@ -757,7 +757,7 @@ mlir::Value OpGen::createSyntaxSpec(Pair* SyntaxSpec, Value OrigCall) {
     // Insert a ContOp for the global that was created.
     TopLevelEnv->Insert(Keyword,
         Context.CreateIdTableEntry(MangledName));
-    Builder.create<ContOp>(Result.getLoc(), Result);
+    ContOp::create(Builder, Result.getLoc(), Result);
     Builder.restoreInsertionPoint(PrevIp);
     // Syntax should be available at compile-time.
     Value GlobalOpVal = SyntaxOp->getParentOp();
diff --git a/heavy/lib/TemplateGen.h b/heavy/lib/TemplateGen.h
diff --git a/heavy/tools/heavy-scheme/heavy_main.cpp b/heavy/tools/heavy-scheme/heavy_main.cpp

Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,7 @@ class OpGen : public ValueVisitor<OpGen, mlir::Value> {`
`243`	`243`	`"Operation must have insertion point");`
`244`	`244`	`mlir::Location MLoc = mlir::OpaqueLoc::get(Loc.getOpaqueEncoding(),`
`245`	`245`	`Builder.getContext());`
`246`		`- return Builder.create<Op>(MLoc, std::forward<Args>(args)...);`
	`246`	`+ return Op::create(Builder, MLoc, std::forward<Args>(args)...);`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`template <typename Op, typename ...Args>`
Original file line number	Diff line number	Diff line change
`@@ -425,7 +425,7 @@ def Nbdl_ScopeOp : Nbdl_Op<"scope", []> {`
`425`	`425`	`let regions = (region SizedRegion<1>:$body);`
`426`	`426`
`427`	`427`	`let builders = [`
`428`		`- OpBuilder<(ins "std::unique_ptr<::mlir::Region>":$body)>`
	`428`	`+ OpBuilder<(ins "std::unique_ptr<::mlir::Region>&&":$body)>`
`429`	`429`	`];`
`430`	`430`	`}`
`431`	`431`