[Heavy] Improve Clang diagnostics integration

Author: ricejasonf

clang/include/clang/Basic/DiagnosticCommonKinds.td

@@ -463,7 +463,9 @@ def warn_try_not_valid_on_target : Warning<
 
 // HeavyScheme
 def err_heavy_scheme : Error<
-    "(HeavyScheme) %0">;
+    "(heavy_scheme) %0">;
 def warn_heavy_scheme : Warning<
-    "(HeavyScheme) %0">;
+    "(heavy_scheme) %0">;
+def note_heavy_scheme : Note<
+    "(heavy_scheme) %0">;
 }

clang/lib/Parse/ParseDeclHeavy.cpp

@@ -32,6 +32,8 @@ using namespace clang;
 
 bool HEAVY_CLANG_IS_LOADED = false;
 heavy::ContextLocal HEAVY_CLANG_VAR(diag_error);
+heavy::ContextLocal HEAVY_CLANG_VAR(diag_warning);
+heavy::ContextLocal HEAVY_CLANG_VAR(diag_note);
 heavy::ContextLocal HEAVY_CLANG_VAR(hello_world);
 heavy::ContextLocal HEAVY_CLANG_VAR(write_lexer);
 heavy::ContextLocal HEAVY_CLANG_VAR(lexer_writer);
@@ -47,6 +49,12 @@ clang::SourceLocation getSourceLocation(heavy::FullSourceLocation Loc) {
      .getLocWithOffset(Loc.getOffset());
 }
 
+clang::SourceLocation getSourceLocation(heavy::HeavyScheme& HS,
+                                        heavy::SourceLocation Loc) {
+  heavy::FullSourceLocation FullLoc = HS.getFullSourceLocation(Loc);
+  return getSourceLocation(FullLoc);
+}
+
 // It is complicated to keep the TokenBuffer alive
 // for the Preprocessor, so we use an array to give
 // ownership via the EnterTokenStream overload.
@@ -135,20 +143,31 @@ bool Parser::ParseHeavyScheme() {
     // Load the static builtin module.
     Parser& P = *this;
     heavy::HeavyScheme& HS = *HeavyScheme;
-    auto diag_error = [&](heavy::Context& C, heavy::ValueRefs Args) {
-      if (Args.size() != 1) {
-        C.RaiseError("invalid arity to function", C.getCallee());
-        return;
-      }
-      if (!isa<heavy::String, heavy::Symbol>(Args[0])) {
-        C.RaiseError("expecting string or identifier", C.getCallee());
-        return;
-      }
-      llvm::StringRef Err = Args[0].getStringRef();
+    auto diag_gen = [&](auto DiagKind) {
+      return [&, DiagKind](heavy::Context& C, heavy::ValueRefs Args) {
+        if (Args.size() < 1 || Args.size() > 2) {
+          C.RaiseError("invalid arity to function", C.getCallee());
+          return;
+        }
 
-      P.Diag(clang::SourceLocation{}, diag::err_heavy_scheme) << Err;
-      C.Cont();
+        if (!isa<heavy::String, heavy::Symbol>(Args[0])) {
+          C.RaiseError("expecting string or identifier", C.getCallee());
+          return;
+        }
+
+        llvm::StringRef Err = Args[0].getStringRef();
+        heavy::SourceLocation Loc;
+        if (Args.size() > 1)
+          Loc = Args[1].getSourceLocation();
+
+        clang::SourceLocation CLoc = getSourceLocation(HS, Loc);
+        P.Diag(CLoc, DiagKind) << Err;
+        C.Cont();
+      };
     };
+    auto diag_error = diag_gen(diag::err_heavy_scheme);
+    auto diag_warning = diag_gen(diag::warn_heavy_scheme);
+    auto diag_note = diag_gen(diag::note_heavy_scheme);
 
     auto hello_world = [](heavy::Context& C, heavy::ValueRefs Args) {
       llvm::errs() << "hello world (from clang)\n";
@@ -300,6 +319,10 @@ bool Parser::ParseHeavyScheme() {
     heavy::base::InitParseSourceFile(Context, ParseSourceFileFn);
     HEAVY_CLANG_VAR(diag_error).init(Context,
                                      Context.CreateLambda(diag_error));
+    HEAVY_CLANG_VAR(diag_warning).init(Context,
+                                       Context.CreateLambda(diag_warning));
+    HEAVY_CLANG_VAR(diag_note).init(Context,
+                                    Context.CreateLambda(diag_note));
     HEAVY_CLANG_VAR(hello_world).init(Context,
                                       Context.CreateLambda(hello_world));
     HEAVY_CLANG_VAR(expr_eval).init(Context,

heavy/include/heavy/Clang.h

@@ -25,13 +25,19 @@
 #define HEAVY_CLANG_INIT              HEAVY_CLANG_LIB##_init
 #define HEAVY_CLANG_VAR(NAME)         HEAVY_CLANG_VAR__##NAME
 #define HEAVY_CLANG_VAR__diag_error   HEAVY_CLANG_LIB_(VS4diagmi5Serror)
+#define HEAVY_CLANG_VAR__diag_warning HEAVY_CLANG_LIB_(VS4diagmi7Swarning)
+#define HEAVY_CLANG_VAR__diag_note    HEAVY_CLANG_LIB_(VS4diagmi4Snote)
 #define HEAVY_CLANG_VAR__hello_world  HEAVY_CLANG_LIB_(V5Shellomi5Sworld)
 #define HEAVY_CLANG_VAR__write_lexer  HEAVY_CLANG_LIB_(V5Swritemi5Slexer)
 #define HEAVY_CLANG_VAR__lexer_writer HEAVY_CLANG_LIB_(V5Slexermi6Swriter)
 #define HEAVY_CLANG_VAR__expr_eval    HEAVY_CLANG_LIB_(V4Sexprmi4Seval)
 
 // diag-error
+// diag-warning
+// diag-note
 extern heavy::ContextLocal HEAVY_CLANG_VAR(diag_error);
+extern heavy::ContextLocal HEAVY_CLANG_VAR(diag_warning);
+extern heavy::ContextLocal HEAVY_CLANG_VAR(diag_note);
 
 // hello-world
 extern heavy::ContextLocal HEAVY_CLANG_VAR(hello_world);
@@ -50,6 +56,10 @@ extern "C" {
 inline void HEAVY_CLANG_INIT(heavy::Context& Context) {
   assert(HEAVY_CLANG_VAR(diag_error).get(Context) &&
       "external module must be preloaded");
+  assert(HEAVY_CLANG_VAR(diag_warning).get(Context) &&
+      "external module must be preloaded");
+  assert(HEAVY_CLANG_VAR(diag_note).get(Context) &&
+      "external module must be preloaded");
   assert(HEAVY_CLANG_VAR(hello_world).get(Context) &&
       "external module must be preloaded");
   assert(HEAVY_CLANG_VAR(write_lexer).get(Context) &&
@@ -66,6 +76,8 @@ inline void HEAVY_CLANG_LOAD_MODULE(heavy::Context& Context) {
   HEAVY_CLANG_INIT(Context);
   heavy::initModuleNames(Context, HEAVY_CLANG_LIB_STR, {
     {"diag-error",  HEAVY_CLANG_VAR(diag_error).init(Context)},
+    {"diag-warning",  HEAVY_CLANG_VAR(diag_warning).init(Context)},
+    {"diag-note",  HEAVY_CLANG_VAR(diag_note).init(Context)},
     {"hello-world", HEAVY_CLANG_VAR(hello_world).init(Context)},
     {"write-lexer", HEAVY_CLANG_VAR(write_lexer).init(Context)},
     {"lexer-writer",HEAVY_CLANG_VAR(lexer_writer).init(Context)},

heavy/lib/Builtins.cpp

@@ -331,9 +331,14 @@ void parse_source_file(Context& C, ValueRefs Args) {
 }
 
 void source_loc(Context& C, ValueRefs Args) {
-  if (Args.size() != 1)
-    return C.RaiseError("expecting single argument");
-  C.Cont(C.CreateSourceValue(Args[0].getSourceLocation()));
+  heavy::SourceLocation Loc;
+  // Take the first valid source location.
+  for (heavy::Value Arg : Args) {
+    Loc = Arg.getSourceLocation();
+    if (Loc.isValid())
+      break;
+  }
+  C.Cont(C.CreateSourceValue(Loc));
 }
 
 } // end of namespace heavy::base

heavy/test/Clang/source-loc.cpp

@@ -0,0 +1,20 @@
+// RUN: clang++ -I %S/Inputs -fsyntax-only -Xclang -fheavy -Xclang -verify %s
+
+#include <type_traits>
+
+// Note that a note requires an error or a warning in order to be displayed.
+// expected-warning@12{{this is a foo}}
+// expected-error@12{{this is still a foo}}
+// expected-note@14{{this is a bar in a list}}
+namespace foo {
+heavy_scheme {
+(import (heavy base) (heavy clang))
+(define foo 'foo)
+(define bar "bar")
+(define baz '(foo bar))
+
+(diag-warning "this is a foo" (source-loc foo))
+(diag-error "this is still a foo" (source-loc bar foo))
+(diag-note "this is a bar in a list" (source-loc (cdr baz) bar foo))
+}
+}