From 780a0bcd3724cad77cb65f931f111273776c9ca4 Mon Sep 17 00:00:00 2001
From: Tim Foley <tfoley@nvidia.com>
Date: Sat, 8 Jul 2017 17:47:31 -0700
Subject: Add back `UnparsedStmt`

If the user doesn't use any `import` declarations, there is no reason to parse their code at all, so having the option of falling back to `UnparsedStmt` can potentially save us some headaches down the road.

The new rule now is that if you have the "no checking" flag on, *and* the parser hasn't yet seen any `import` declarations, then it still used `UnparsedStmt` to avoid touching function bodies.
Otherwise, I go ahead and parse function bodies, and assume I can rewrite any code I can semantically understand.
---
 source/slang/parser.cpp | 56 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

(limited to 'source/slang/parser.cpp')

diff --git a/source/slang/parser.cpp b/source/slang/parser.cpp
index 199275a2d..759fc0c20 100644
--- a/source/slang/parser.cpp
+++ b/source/slang/parser.cpp
@@ -44,6 +44,11 @@ namespace Slang
         String fileName;
         int genericDepth = 0;
 
+        // Have we seen any `import` declarations? If so, we need
+        // to parse function bodies completely, even if we are in
+        // "rewrite" mode.
+        bool haveSeenAnyImportDecls = false;
+
         // Is the parser in a "recovering" state?
         // During recovery we don't emit additional errors, until we find
         // a token that we expected, when we exit recovery.
@@ -802,6 +807,8 @@ namespace Slang
     static RefPtr<Decl> parseImportDecl(
         Parser* parser)
     {
+        parser->haveSeenAnyImportDecls = true;
+
         parser->ReadToken("__import");
 
         auto decl = new ImportDecl();
@@ -842,6 +849,8 @@ namespace Slang
     static RefPtr<Decl> parsePoundImportDecl(
         Parser* parser)
     {
+        parser->haveSeenAnyImportDecls = true;
+
         Token importToken = parser->ReadToken(TokenType::PoundImport);
 
         auto decl = new ImportDecl();
@@ -2599,6 +2608,53 @@ namespace Slang
 
     RefPtr<StatementSyntaxNode> Parser::ParseBlockStatement()
     {
+        // If we are being asked not to check things *and* we haven't
+        // seen any `import` declarations yet, then we can safely assume
+        // that function bodies should be left as-is.
+        if( (translationUnit->compileFlags & SLANG_COMPILE_FLAG_NO_CHECKING)
+            && !haveSeenAnyImportDecls )
+        {
+            // We have been asked to parse the input, but not attempt to understand it.
+
+            // TODO: record start/end locations...
+
+            List<Token> tokens;
+
+            ReadToken(TokenType::LBrace);
+
+            int depth = 1;
+            for( ;;)
+            {
+                switch( tokenReader.PeekTokenType() )
+                {
+                case TokenType::EndOfFile:
+                    goto done;
+
+                case TokenType::RBrace:
+                    depth--;
+                    if(depth == 0)
+                        goto done;
+                    break;
+
+                case TokenType::LBrace:
+                    depth++;
+                    break;
+
+                default:
+                    break;
+                }
+
+                auto token = tokenReader.AdvanceToken();
+                tokens.Add(token);
+            }
+        done:
+            ReadToken(TokenType::RBrace);
+
+            RefPtr<UnparsedStmt> unparsedStmt = new UnparsedStmt();
+            unparsedStmt->tokens = tokens;
+            return unparsedStmt;
+        }
+
         RefPtr<ScopeDecl> scopeDecl = new ScopeDecl();
         RefPtr<BlockStmt> blockStatement = new BlockStmt();
         blockStatement->scopeDecl = scopeDecl;
-- 
cgit v1.2.3