Support "modern" declaration syntax as an option (shader-slang#792)

* Support "modern" declaration syntax as an option

Fixed shader-slang#202

This change adds four new declaration keywords:

The `let` and `var` keywords introduce immutable and mutable variables, respectively. They can only be used to declare a single variable at a time (unlike C declaration syntax), and they support inference of the variable's type from its initial-value expression.

Examples:

```
let a : int = 1; // immutable with explicit type and initial-value expression
let b = a + 1;   // immutable, with type inferred
var c : float;   // mutable, with explicit type
var d = b + c;   // mutable, with type inferred
```

These declaration forms can be used wherever ordinary global, local, or member variable declarations appeared before. Right now they do not change rules about what is or is not considered a shader parameter. The `static` modifier should work on these forms as expected, but a `static let` variable is *not* the same as a `static const`, so an explicit `const` is still needed if you want that behavior.

A `typealias` declaration introduces a named type alias, similar to `typedef`, but with more reasonable syntax. It inherits from the same AST class that `typedef` uses, so all of the code after parsing should be able to treat them as equivalent. To give a simple example:

```
// typedef int MyArray[3];
typealais MyArray = int[3];
```

A `func` declaration introduces a function. Like `typealias` it re-uses the existing AST class, so there is no need for major changes after parsing. A `func` declaration uses a syntax similar to `let` variables for its parameters, and takes the (optional) result type in a trailing position. For example:

```
func myAdd(a: int, b: int) -> int { return a + b; }
```

If a `func` declaration leaves of the return type clause, the return type is assumed to be `void`.

The main difference (beyond the trailing return type) is that the parameters of a `func`-declared function are immutable (unless they are `out`/`inout`).

This change doesn't add support for declaring operator overloads with `func`, but that should be added later, and I'd like to make that the only way to declare such operations:

```
func +(left: MyType, right: MyType) -> MyType { ... }
```

The use of `:` for declaring parameter types here means that a function declared with modern syntax currently cannot include HLSL-style semantics on its parameters (or its result).
We might consider introducing an `[attribute]`-based syntax for adding semantics to parameters if we think this is important, but for now it is fine to insist that users declare their entry points using traditional syntax.

This change strives to avoid unecessary changes after parsing, but if the new syntax catches on with users there are some small ways we can take advantage of it for performance. In particular, since `let` declarations and parameters of modern-style functions are immutable, we do not need to generate read/write local temporaries for them during lowering to the IR (technically we can make the same optimization for `const` locals).

In the process of implementing these new forms I also added a few subroutines to help share code better between existing cases in the parser. In particular, parsing of generic parameter lists on declarations that can be generic is now simplified and more unified.

* Fixup: remove leftover debugging code

* fixup: typos

Author: Tim Foley

source/slang/check.cpp

@@ -2134,39 +2134,74 @@ namespace Slang
 
         void CheckVarDeclCommon(RefPtr<VarDeclBase> varDecl)
         {
-            if (function || checkingPhase == CheckingPhase::Header)
+            // A variable that didn't have an explicit type written must
+            // have its type inferred from the initial-value expresison.
+            //
+            if(!varDecl->type.exp)
             {
-                TypeExp typeExp = CheckUsableType(varDecl->type);
-                varDecl->type = typeExp;
-                if (varDecl->type.Equals(getSession()->getVoidType()))
+                // In this case we need to perform all checking of the
+                // variable (including semantic checking of the initial-value
+                // expression) during the first phase of checking.
+
+                auto initExpr = varDecl->initExpr;
+                if(!initExpr)
                 {
-                    getSink()->diagnose(varDecl, Diagnostics::invalidTypeVoid);
+                    getSink()->diagnose(varDecl, Diagnostics::varWithoutTypeMustHaveInitializer);
+                    varDecl->type.type = getSession()->getErrorType();
                 }
-            }
+                else
+                {
+                    initExpr = CheckExpr(initExpr);
 
-            if (checkingPhase == CheckingPhase::Body)
+                    // TODO: We might need some additional steps here to ensure
+                    // that the type of the expression is one we are okay with
+                    // inferring. E.g., if we ever decide that integer and floating-point
+                    // literals have a distinct type from the standard int/float types,
+                    // then we would need to "decay" a literal to an explicit type here.
+
+                    varDecl->initExpr = initExpr;
+                    varDecl->type.type = initExpr->type;
+                }
+
+                varDecl->SetCheckState(DeclCheckState::Checked);
+            }
+            else
             {
-                if (auto initExpr = varDecl->initExpr)
+                if (function || checkingPhase == CheckingPhase::Header)
                 {
-                    initExpr = CheckTerm(initExpr);
-                    initExpr = Coerce(varDecl->type.Ptr(), initExpr);
-                    varDecl->initExpr = initExpr;
+                    TypeExp typeExp = CheckUsableType(varDecl->type);
+                    varDecl->type = typeExp;
+                    if (varDecl->type.Equals(getSession()->getVoidType()))
+                    {
+                        getSink()->diagnose(varDecl, Diagnostics::invalidTypeVoid);
+                    }
+                }
 
-                    // If this is an array variable, then we first want to give
-                    // it a chance to infer an array size from its initializer
-                    //
-                    // TODO(tfoley): May need to extend this to handle the
-                    // multi-dimensional case...
-                    //
-                    maybeInferArraySizeForVariable(varDecl);
-                    //
-                    // Next we want to make sure that the declared (or inferred)
-                    // size for the array meets whatever language-specific
-                    // constraints we want to enforce (e.g., disallow empty
-                    // arrays in specific cases)
-                    //
-                    validateArraySizeForVariable(varDecl);
+                if (checkingPhase == CheckingPhase::Body)
+                {
+                    if (auto initExpr = varDecl->initExpr)
+                    {
+                        initExpr = CheckTerm(initExpr);
+                        initExpr = Coerce(varDecl->type.Ptr(), initExpr);
+                        varDecl->initExpr = initExpr;
+
+                        // If this is an array variable, then we first want to give
+                        // it a chance to infer an array size from its initializer
+                        //
+                        // TODO(tfoley): May need to extend this to handle the
+                        // multi-dimensional case...
+                        //
+                        maybeInferArraySizeForVariable(varDecl);
+                        //
+                        // Next we want to make sure that the declared (or inferred)
+                        // size for the array meets whatever language-specific
+                        // constraints we want to enforce (e.g., disallow empty
+                        // arrays in specific cases)
+                        //
+                        validateArraySizeForVariable(varDecl);
+                    }
                 }
+
             }
             varDecl->SetCheckState(getCheckedState());
         }
@@ -4289,8 +4324,19 @@ namespace Slang
             functionNode->SetCheckState(DeclCheckState::CheckingHeader);
             auto oldFunc = this->function;
             this->function = functionNode;
-            auto returnType = CheckProperType(functionNode->ReturnType);
-            functionNode->ReturnType = returnType;
+
+            auto resultType = functionNode->ReturnType;
+            if(resultType.exp)
+            {
+                resultType = CheckProperType(functionNode->ReturnType);
+            }
+            else
+            {
+                resultType = TypeExp(getSession()->getVoidType());
+            }
+            functionNode->ReturnType = resultType;
+
+
             HashSet<Name*> paraNames;
             for (auto & para : functionNode->GetParameters())
             {
@@ -9535,6 +9581,28 @@ namespace Slang
             if(isGlobalShaderParameter(varDeclRef.getDecl()))
                 isLValue = false;
 
+            // Variables declared with `let` are always immutable.
+            if(varDeclRef.As<LetDecl>())
+                isLValue = false;
+
+            // Generic value parameters are always immutable
+            if(varDeclRef.As<GenericValueParamDecl>())
+                isLValue = false;
+
+            // Function parameters declared in the "modern" style
+            // are immutable unless they have an `out` or `inout` modifier.
+            if( varDeclRef.As<ModernParamDecl>() )
+            {
+                // Note: the `inout` modifier AST class inherits from
+                // the class for the `out` modifier so that we can
+                // make simple checks like this.
+                //
+                if( !varDeclRef.getDecl()->HasModifier<OutModifier>() )
+                {
+                    isLValue = false;
+                }
+            }
+
             qualType.IsLeftValue = isLValue;
             return qualType;
         }

source/slang/decl-defs.h

@@ -51,6 +51,10 @@ END_SYNTAX_CLASS()
 SYNTAX_CLASS(VarDecl, VarDeclBase)
 END_SYNTAX_CLASS()
 
+// A variable declaration that is always immutable (whether local, global, or member variable)
+SYNTAX_CLASS(LetDecl, VarDecl)
+END_SYNTAX_CLASS()
+
 // An `AggTypeDeclBase` captures the shared functionality
 // between true aggregate type declarations and extension
 // declarations:
@@ -165,6 +169,8 @@ SYNTAX_CLASS(TypeDefDecl, SimpleTypeDecl)
     SYNTAX_FIELD(TypeExp, type)
 END_SYNTAX_CLASS()
 
+SIMPLE_SYNTAX_CLASS(TypeAliasDecl, TypeDefDecl)
+
 // An 'assoctype' declaration, it is a container of inheritance clauses
 SYNTAX_CLASS(AssocTypeDecl, AggTypeDecl)
 END_SYNTAX_CLASS()
@@ -180,6 +186,9 @@ SIMPLE_SYNTAX_CLASS(ScopeDecl, ContainerDecl)
 // A function/initializer/subscript parameter (potentially mutable)
 SIMPLE_SYNTAX_CLASS(ParamDecl, VarDeclBase)
 
+// A parameter of a function declared in "modern" types (immutable unless explicitly `out` or `inout`)
+SIMPLE_SYNTAX_CLASS(ModernParamDecl, ParamDecl)
+
 // Base class for things that have parameter lists and can thus be applied to arguments ("called")
 ABSTRACT_SYNTAX_CLASS(CallableDecl, ContainerDecl)
     RAW(

source/slang/diagnostic-defs.h

@@ -289,7 +289,8 @@ DIAGNOSTIC(30501, Error, cannotUseInitializerListForArrayOfUnknownSize, "cannot
 DIAGNOSTIC(30502, Error, cannotUseInitializerListForVectorOfUnknownSize, "cannot use initializer list for vector of statically unknown size '$0'");
 DIAGNOSTIC(30503, Error, cannotUseInitializerListForMatrixOfUnknownSize, "cannot use initializer list for matrix of statically unknown size '$0' rows");
 
-
+// 306xx: variables
+DIAGNOSTIC(30600, Error, varWithoutTypeMustHaveInitializer, "a variable declaration without an initial-value expression must be given an explicit type");
 
 DIAGNOSTIC(39999, Error, expectedIntegerConstantWrongType, "expected integer constant (found: '$0')")
 DIAGNOSTIC(39999, Error, expectedIntegerConstantNotConstant, "expression does not evaluate to a compile-time constant")