Improve behavior when undefined identifier is a contextual keyword (#1200)

The HLSL language has keywords with very common names like `triangle`, and Slang doesn't want to preclude users from using such names for their variables/functions/etc.
In addition, Slang adds new keywords on top of HLSL (like `extension`) and we don't want those to prevent us from compiling existing code.
As a result, almost all keywords in Slang are contextual keywords, and they can be shadowed by user varaibles.

The down-side to making all keywords contextual is that in a case like this:

```
int test() { return triangle; }
```

The identifier `triangle` is *not* undefined as far as lookup (it is defined as a modifier keyword), so the existing "undefined identifier" logic gets bypassed, and instead we ran into an internal compiler error trying to construct an expression that refers to a modifier keyword.

Fortunately, the internal compiler error in that case was overkill, and the compiler already had defensive logic to produce an expression with an error type if it couldn't figure out what the type of a declaration reference should be.

The main fix here is thus to emit an "undefined identifier" error instead of an internal compiler error at the point where we see an attempt to reference a declaration that shouldn't be available in an expression context.

In order to improve the quality of the diagnostic, the code for constructing declaration references was updated to pass along a source location to be used in error messages.

1 files changed, 1 insertions, 1 deletions

diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp
index f1c1b9a43..e7db665ae 100644
--- a/source/slang/slang-check-expr.cpp
+++ b/source/slang/slang-check-expr.cpp
@@ -177,7 +177,7 @@ namespace Slang
     {
         // Compute the type that this declaration reference will have in context.
         //
-        auto type = GetTypeForDeclRef(declRef);
+        auto type = GetTypeForDeclRef(declRef, loc);
 
         // Construct an appropriate expression based on the structured of
         // the declaration reference.