From 03de737f0d18526b99b59a1810c7e290b66f4be2 Mon Sep 17 00:00:00 2001 From: Tim Foley Date: Thu, 6 Jul 2017 11:11:01 -0700 Subject: Fix many warnings-as-errors issues. The code should now compile cleanly with warnings as errors for VS2015 with `W3`. Most of the changes had to do with propagating a real pointer-sized integer type through code that had been using `int`. --- source/slang/lower.cpp | 26 ++++++++++++-------------- 1 file changed, 12 insertions(+), 14 deletions(-) (limited to 'source/slang/lower.cpp') diff --git a/source/slang/lower.cpp b/source/slang/lower.cpp index 674614cd3..e03fd878b 100644 --- a/source/slang/lower.cpp +++ b/source/slang/lower.cpp @@ -80,7 +80,7 @@ struct StructuralTransformStmtVisitor : StructuralTransformVisitorBase , StmtVisitor, RefPtr> { - void transformFields(StatementSyntaxNode* result, StatementSyntaxNode* obj) + void transformFields(StatementSyntaxNode*, StatementSyntaxNode*) { } @@ -457,7 +457,7 @@ struct LoweringVisitor // StatementSyntaxNode* translateStmtRef( - StatementSyntaxNode* stmt) + StatementSyntaxNode*) { throw "unimplemented"; } @@ -666,13 +666,13 @@ struct LoweringVisitor } RefPtr translateSubstitutions( - Substitutions* substitutions) + Substitutions* inSubstitutions) { - if (!substitutions) return nullptr; + if (!inSubstitutions) return nullptr; RefPtr result = new Substitutions(); - result->genericDecl = translateDeclRef(substitutions->genericDecl).As(); - for (auto arg : substitutions->args) + result->genericDecl = translateDeclRef(inSubstitutions->genericDecl).As(); + for (auto arg : inSubstitutions->args) { result->args.Add(translateVal(arg)); } @@ -740,9 +740,8 @@ struct LoweringVisitor } else { - DeclVisitor::dispatch(declBase); + return DeclVisitor::dispatch(declBase); } - } RefPtr lowerDecl( @@ -922,8 +921,8 @@ struct LoweringVisitor // // If this is a global variable (program scope), then add it // to the global scope. - RefPtr parentDecl = decl->ParentDecl; - if (auto parentModuleDecl = parentDecl.As()) + RefPtr pp = decl->ParentDecl; + if (auto parentModuleDecl = pp.As()) { addMember( translateDeclRef(parentModuleDecl), @@ -1138,10 +1137,6 @@ struct LoweringVisitor subscriptExpr->Position = varExpr->Position; subscriptExpr->BaseExpression = varExpr; - // TODO: we need to construct syntax for a loop to initialize - // the array here... - throw "unimplemented"; - // Note that we use the original `varLayout` that was passed in, // since that is the layout that will ultimately need to be // used on the array elements. @@ -1154,6 +1149,9 @@ struct LoweringVisitor varLayout, subscriptExpr); + // TODO: we need to construct syntax for a loop to initialize + // the array here... + throw "unimplemented"; } else if (auto declRefType = varType->As()) { -- cgit v1.2.3 From e05fba99e9f4fa08b6252e31c39b0d5ac2d23a34 Mon Sep 17 00:00:00 2001 From: Tim Foley Date: Thu, 6 Jul 2017 11:29:59 -0700 Subject: Add missing declaration types to lowering pass. Most of these are cases we don't expect to encounter, but the big missing one was `TypeDefDecl`. --- source/core/exception.h | 7 ++++++ source/slang/lower.cpp | 65 ++++++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 68 insertions(+), 4 deletions(-) (limited to 'source/slang/lower.cpp') diff --git a/source/core/exception.h b/source/core/exception.h index 6739c6778..dc674de7f 100644 --- a/source/core/exception.h +++ b/source/core/exception.h @@ -110,6 +110,13 @@ namespace Slang { } }; + + #define SLANG_UNEXPECTED(reason) \ + throw Slang::Exception("unexpected: " reason) + + #define SLANG_UNIMPLEMENTED_X(what) \ + throw Slang::NotImplementedException("unimplemented: " what) + } #endif \ No newline at end of file diff --git a/source/slang/lower.cpp b/source/slang/lower.cpp index e03fd878b..8a732467c 100644 --- a/source/slang/lower.cpp +++ b/source/slang/lower.cpp @@ -826,11 +826,68 @@ struct LoweringVisitor } // Catch-all - RefPtr visit( - Decl* decl) + + RefPtr visit(ModifierDecl*) { - assert(!"unimplemented"); - return decl; + // should not occur in user code + SLANG_UNEXPECTED("modifiers shouldn't occur in user code"); + } + + RefPtr visit(GenericValueParamDecl*) + { + SLANG_UNEXPECTED("generics should be lowered to specialized decls"); + } + + RefPtr visit(GenericTypeParamDecl*) + { + SLANG_UNEXPECTED("generics should be lowered to specialized decls"); + } + + RefPtr visit(GenericTypeConstraintDecl*) + { + SLANG_UNEXPECTED("generics should be lowered to specialized decls"); + } + + RefPtr visit(GenericDecl*) + { + SLANG_UNEXPECTED("generics should be lowered to specialized decls"); + } + + RefPtr visit(ProgramSyntaxNode*) + { + SLANG_UNEXPECTED("module decls should be lowered explicitly"); + } + + RefPtr visit(SubscriptDecl*) + { + // We don't expect to find direct references to a subscript + // declaration, but rather to the underlying accessors + return nullptr; + } + + RefPtr visit(InheritanceDecl*) + { + // We should deal with these explicitly, as part of lowering + // the type that contains them. + return nullptr; + } + + RefPtr visit(ExtensionDecl*) + { + // Extensions won't exist in the lowered code: their members + // will turn into ordinary functions that get called explicitly + return nullptr; + } + + RefPtr visit(TypeDefDecl* decl) + { + RefPtr loweredDecl = new TypeDefDecl(); + lowerDeclCommon(loweredDecl, decl); + + loweredDecl->Type = lowerType(decl->Type); + + addMember(shared->loweredProgram, loweredDecl); + return loweredDecl; } RefPtr visit(ImportDecl* decl) -- cgit v1.2.3 From 098a5442caeb2e9505864e985900d4793014dffc Mon Sep 17 00:00:00 2001 From: Tim Foley Date: Thu, 6 Jul 2017 12:30:19 -0700 Subject: More exhaustive lowering - Handle all statement cases explicitly (rather than falling back to the "structural recursion" mess) - Handle back-references from child statements to their parents --- source/slang/emit.cpp | 7 +- source/slang/lower.cpp | 203 +++++++++++++++++++++++++++++++++++++++++++++---- 2 files changed, 195 insertions(+), 15 deletions(-) (limited to 'source/slang/lower.cpp') diff --git a/source/slang/emit.cpp b/source/slang/emit.cpp index 0b79cb52f..79a8277bf 100644 --- a/source/slang/emit.cpp +++ b/source/slang/emit.cpp @@ -1491,12 +1491,15 @@ static void EmitType(EmitContext* context, RefPtr type) static void EmitType(EmitContext* context, TypeExp const& typeExp, Token const& nameToken) { EmitType(context, typeExp.type, - typeExp.exp ? typeExp.exp->Position : CodePosition(), nameToken.Content, nameToken.Position); + typeExp.exp ? typeExp.exp->Position : CodePosition(), + nameToken.Content, nameToken.Position); } static void EmitType(EmitContext* context, TypeExp const& typeExp, String const& name) { - EmitType(context, typeExp.type, typeExp.exp->Position, name, CodePosition()); + EmitType(context, typeExp.type, + typeExp.exp ? typeExp.exp->Position : CodePosition(), + name, CodePosition()); } // Statements diff --git a/source/slang/lower.cpp b/source/slang/lower.cpp index 8a732467c..f9bf97107 100644 --- a/source/slang/lower.cpp +++ b/source/slang/lower.cpp @@ -60,6 +60,7 @@ struct StructuralTransformVisitorBase RefPtr transformSyntaxField(ScopeDecl* decl) { + if(!decl) return nullptr; return visitor->transformSyntaxField(decl).As(); } @@ -263,6 +264,7 @@ struct LoweringVisitor RefPtr lowerType( ExpressionType* type) { + if(!type) return nullptr; return TypeVisitor::dispatch(type); } @@ -456,12 +458,11 @@ struct LoweringVisitor // Statements // - StatementSyntaxNode* translateStmtRef( - StatementSyntaxNode*) - { - throw "unimplemented"; - } - + // Lowering one statement to another. + // The source statement might desugar into multiple statements, + // (or event to none), and in such a case this function wraps + // the result up as a `SeqStmt` or `EmptyStmt` as appropriate. + // RefPtr lowerStmt( StatementSyntaxNode* stmt) { @@ -483,6 +484,37 @@ struct LoweringVisitor } } + + // Structure to track "outer" statements during lowering + struct StmtLoweringState + { + // The next "outer" statement entry + StmtLoweringState* parent = nullptr; + + // The outer statement (both lowered and original) + StatementSyntaxNode* loweredStmt = nullptr; + StatementSyntaxNode* originalStmt = nullptr; + }; + StmtLoweringState stmtLoweringState; + + // Translate a reference from one statement to an outer statement + StatementSyntaxNode* translateStmtRef( + StatementSyntaxNode* originalStmt) + { + if(!originalStmt) return nullptr; + + for( auto state = &stmtLoweringState; state; state = state->parent ) + { + if(state->originalStmt == originalStmt) + return state->loweredStmt; + } + + assert(!"unexepcted"); + + return nullptr; + } + + // Expand a statement to be lowered into one or more statements void lowerStmtImpl( StatementSyntaxNode* stmt) { @@ -498,14 +530,17 @@ struct LoweringVisitor LoweringVisitor pushScope( RefPtr loweredStmt, - RefPtr stmt) + RefPtr originalStmt) { - loweredStmt->scopeDecl = translateDeclRef(stmt->scopeDecl).As(); + loweredStmt->scopeDecl = translateDeclRef(originalStmt->scopeDecl).As(); LoweringVisitor subVisitor = *this; subVisitor.isBuildingStmt = true; subVisitor.stmtBeingBuilt = nullptr; subVisitor.parentDecl = loweredStmt->scopeDecl; + subVisitor.stmtLoweringState.parent = &stmtLoweringState; + subVisitor.stmtLoweringState.originalStmt = originalStmt; + subVisitor.stmtLoweringState.loweredStmt = loweredStmt; return subVisitor; } @@ -562,11 +597,11 @@ struct LoweringVisitor void visit(BlockStmt* stmt) { RefPtr loweredStmt = new BlockStmt(); + lowerScopeStmtFields(loweredStmt, stmt); LoweringVisitor subVisitor = pushScope(loweredStmt, stmt); - subVisitor.stmtBeingBuilt = loweredStmt; - subVisitor.lowerStmtImpl(stmt->body); + loweredStmt->body = subVisitor.lowerStmt(stmt->body); addStmt(loweredStmt); } @@ -589,10 +624,152 @@ struct LoweringVisitor DeclVisitor::dispatch(stmt->decl); } - // catch-all - void visit(StatementSyntaxNode* stmt) + void lowerStmtFields( + StatementSyntaxNode* loweredStmt, + StatementSyntaxNode* originalStmt) + { + loweredStmt->Position = originalStmt->Position; + loweredStmt->modifiers = originalStmt->modifiers; + } + + void lowerScopeStmtFields( + ScopeStmt* loweredStmt, + ScopeStmt* originalStmt) + { + lowerStmtFields(loweredStmt, originalStmt); + loweredStmt->scopeDecl = translateDeclRef(originalStmt->scopeDecl).As(); + } + + // Child statements reference their parent statement, + // so we need to translate that cross-reference + void lowerChildStmtFields( + ChildStmt* loweredStmt, + ChildStmt* originalStmt) + { + lowerStmtFields(loweredStmt, originalStmt); + + loweredStmt->parentStmt = translateStmtRef(originalStmt->parentStmt); + } + + void visit(ContinueStatementSyntaxNode* stmt) + { + RefPtr loweredStmt = new ContinueStatementSyntaxNode(); + lowerChildStmtFields(loweredStmt, stmt); + addStmt(loweredStmt); + } + + void visit(BreakStatementSyntaxNode* stmt) + { + RefPtr loweredStmt = new BreakStatementSyntaxNode(); + lowerChildStmtFields(loweredStmt, stmt); + addStmt(loweredStmt); + } + + void visit(DefaultStmt* stmt) + { + RefPtr loweredStmt = new DefaultStmt(); + lowerChildStmtFields(loweredStmt, stmt); + addStmt(loweredStmt); + } + + void visit(DiscardStatementSyntaxNode* stmt) + { + RefPtr loweredStmt = new DiscardStatementSyntaxNode(); + lowerStmtFields(loweredStmt, stmt); + addStmt(loweredStmt); + } + + void visit(EmptyStatementSyntaxNode* stmt) + { + RefPtr loweredStmt = new EmptyStatementSyntaxNode(); + lowerStmtFields(loweredStmt, stmt); + addStmt(loweredStmt); + } + + void visit(UnparsedStmt* stmt) { - auto loweredStmt = structuralTransform(stmt, this); + RefPtr loweredStmt = new UnparsedStmt(); + lowerStmtFields(loweredStmt, stmt); + + loweredStmt->tokens = stmt->tokens; + + addStmt(loweredStmt); + } + + void visit(CaseStmt* stmt) + { + RefPtr loweredStmt = new CaseStmt(); + lowerChildStmtFields(loweredStmt, stmt); + + loweredStmt->expr = lowerExpr(stmt->expr); + + addStmt(loweredStmt); + } + + void visit(IfStatementSyntaxNode* stmt) + { + RefPtr loweredStmt = new IfStatementSyntaxNode(); + lowerStmtFields(loweredStmt, stmt); + + loweredStmt->Predicate = lowerExpr(stmt->Predicate); + loweredStmt->PositiveStatement = lowerStmt(stmt->PositiveStatement); + loweredStmt->NegativeStatement = lowerStmt(stmt->NegativeStatement); + + addStmt(loweredStmt); + } + + void visit(SwitchStmt* stmt) + { + RefPtr loweredStmt = new SwitchStmt(); + lowerScopeStmtFields(loweredStmt, stmt); + + LoweringVisitor subVisitor = pushScope(loweredStmt, stmt); + + loweredStmt->condition = subVisitor.lowerExpr(stmt->condition); + loweredStmt->body = subVisitor.lowerStmt(stmt->body); + + addStmt(loweredStmt); + } + + + void visit(ForStatementSyntaxNode* stmt) + { + RefPtr loweredStmt = new ForStatementSyntaxNode(); + lowerScopeStmtFields(loweredStmt, stmt); + + LoweringVisitor subVisitor = pushScope(loweredStmt, stmt); + + loweredStmt->InitialStatement = subVisitor.lowerStmt(stmt->InitialStatement); + loweredStmt->SideEffectExpression = subVisitor.lowerExpr(stmt->SideEffectExpression); + loweredStmt->PredicateExpression = subVisitor.lowerExpr(stmt->PredicateExpression); + loweredStmt->Statement = subVisitor.lowerStmt(stmt->Statement); + + addStmt(loweredStmt); + } + + void visit(WhileStatementSyntaxNode* stmt) + { + RefPtr loweredStmt = new WhileStatementSyntaxNode(); + lowerScopeStmtFields(loweredStmt, stmt); + + LoweringVisitor subVisitor = pushScope(loweredStmt, stmt); + + loweredStmt->Predicate = subVisitor.lowerExpr(stmt->Predicate); + loweredStmt->Statement = subVisitor.lowerStmt(stmt->Statement); + + addStmt(loweredStmt); + } + + void visit(DoWhileStatementSyntaxNode* stmt) + { + RefPtr loweredStmt = new DoWhileStatementSyntaxNode(); + lowerScopeStmtFields(loweredStmt, stmt); + + LoweringVisitor subVisitor = pushScope(loweredStmt, stmt); + + loweredStmt->Statement = subVisitor.lowerStmt(stmt->Statement); + loweredStmt->Predicate = subVisitor.lowerExpr(stmt->Predicate); + addStmt(loweredStmt); } -- cgit v1.2.3