Revise how hidden implicit casts are recognized.

The old approach used an `isRewriter` flag in the emit logic, but I kind of need that flag to go away.
Instead, I now how the semantic checking pass detect whether an implicitly-generated type cast is in rewriter code, and if so it uses the new `HiddenImplicitCastExpr` AST node.
The emit logic then looks for that specific node and eliminates it.

4 files changed, 32 insertions, 12 deletions

diff --git a/source/slang/check.cpp b/source/slang/check.cpp
index f21f9480c..556f141c0 100644
--- a/source/slang/check.cpp
+++ b/source/slang/check.cpp
@@ -987,7 +987,19 @@ namespace Slang
             RefPtr<ExpressionType>			toType,
             RefPtr<ExpressionSyntaxNode>	fromExpr)
         {
-            auto castExpr = new ImplicitCastExpr();
+            // In "rewrite" mode, we will generate a different syntax node
+            // to indicate that this type-cast was implicitly generated
+            // by the compiler, and shouldn't appear in the output code.
+            RefPtr<TypeCastExpressionSyntaxNode> castExpr;
+            if (isRewriteMode())
+            {
+                castExpr = new HiddenImplicitCastExpr();
+            }
+            else
+            {
+                castExpr = new ImplicitCastExpr();
+            }
+
             castExpr->Position = fromExpr->Position;
             castExpr->TargetType.type = toType;
             castExpr->Type = QualType(toType);
diff --git a/source/slang/emit.cpp b/source/slang/emit.cpp
index a1d95ca7e..a8c0083c1 100644
--- a/source/slang/emit.cpp
+++ b/source/slang/emit.cpp
@@ -2031,18 +2031,15 @@ struct EmitVisitor
         if(needClose) Emit(")");
     }
 
-    void visitTypeCastExpressionSyntaxNode(TypeCastExpressionSyntaxNode* castExpr, ExprEmitArg const& arg)
+    void visitHiddenImplicitCastExpr(HiddenImplicitCastExpr* castExpr, ExprEmitArg const& arg)
     {
-        if (context->isRewrite)
-        {
-            if (dynamic_cast<ImplicitCastExpr*>(castExpr))
-            {
-                // This was an implicit cast, so don't try to output it
-                ExprVisitorWithArg::dispatch(castExpr->Expression, arg);
-                return;
-            }
-        }
+        // This was an implicit cast inserted in code parsed in "rewriter" mode,
+        // so we don't want to output it and change what the user's code looked like.
+        ExprVisitorWithArg::dispatch(castExpr->Expression, arg);
+    }
 
+    void visitTypeCastExpressionSyntaxNode(TypeCastExpressionSyntaxNode* castExpr, ExprEmitArg const& arg)
+    {
         bool needClose = false;
         switch(context->shared->target)
         {
diff --git a/source/slang/expr-defs.h b/source/slang/expr-defs.h
index 5ca6629b9..0dac324b9 100644
--- a/source/slang/expr-defs.h
+++ b/source/slang/expr-defs.h
@@ -91,14 +91,25 @@ SYNTAX_CLASS(DerefExpr, ExpressionSyntaxNode)
     SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, base)
 END_SYNTAX_CLASS()
 
+// Any operation that performs type-casting
 SYNTAX_CLASS(TypeCastExpressionSyntaxNode, ExpressionSyntaxNode)
     SYNTAX_FIELD(TypeExp, TargetType)
     SYNTAX_FIELD(RefPtr<ExpressionSyntaxNode>, Expression)
 END_SYNTAX_CLASS()
 
+// An explicit type-cast that appear in the user's code with `(Type) expr` syntax
+SYNTAX_CLASS(ExplicitCastExpr, TypeCastExpressionSyntaxNode)
+END_SYNTAX_CLASS()
+
+// An implicit type-cast inserted during semantic checking
 SYNTAX_CLASS(ImplicitCastExpr, TypeCastExpressionSyntaxNode)
 END_SYNTAX_CLASS()
 
+// An implicit type-cast that should also be hidden on output,
+// because we don't want to mess with the user's code
+SYNTAX_CLASS(HiddenImplicitCastExpr, ImplicitCastExpr)
+END_SYNTAX_CLASS()
+
 SIMPLE_SYNTAX_CLASS(SelectExpressionSyntaxNode, OperatorExpressionSyntaxNode)
 
 SIMPLE_SYNTAX_CLASS(GenericAppExpr, AppExprBase)
diff --git a/source/slang/parser.cpp b/source/slang/parser.cpp
index 2056bf809..0efc8cd77 100644
--- a/source/slang/parser.cpp
+++ b/source/slang/parser.cpp
@@ -3092,7 +3092,7 @@ namespace Slang
 
                 if (peekTypeName(parser) && parser->LookAheadToken(TokenType::RParent, 1))
                 {
-                    RefPtr<TypeCastExpressionSyntaxNode> tcexpr = new TypeCastExpressionSyntaxNode();
+                    RefPtr<TypeCastExpressionSyntaxNode> tcexpr = new ExplicitCastExpr();
                     parser->FillPosition(tcexpr.Ptr());
                     tcexpr->TargetType = parser->ParseTypeExp();
                     parser->ReadToken(TokenType::RParent);