From cbc1eff56057f199183bb7c17d8a360326512367 Mon Sep 17 00:00:00 2001
From: Yong He <yonghe@outlook.com>
Date: Tue, 1 Nov 2022 08:46:57 -0700
Subject: Make `DifferentialPair` able to nest. (#2477)

---
 source/slang/slang-ast-synthesis.cpp | 175 +++++++++++++++++++++++++++++++++++
 1 file changed, 175 insertions(+)
 create mode 100644 source/slang/slang-ast-synthesis.cpp

(limited to 'source/slang/slang-ast-synthesis.cpp')

diff --git a/source/slang/slang-ast-synthesis.cpp b/source/slang/slang-ast-synthesis.cpp
new file mode 100644
index 000000000..e5a9ff75f
--- /dev/null
+++ b/source/slang/slang-ast-synthesis.cpp
@@ -0,0 +1,175 @@
+#include "slang-ast-synthesis.h"
+
+namespace Slang
+{
+Expr* ASTSynthesizer::emitBinaryExpr(UnownedStringSlice operatorToken, Expr* left, Expr* right)
+{
+    auto infixExpr = m_builder->create<InfixExpr>();
+    infixExpr->functionExpr = emitVarExpr(m_namePool->getName(operatorToken));;
+    infixExpr->arguments.add(left);
+    infixExpr->arguments.add(right);
+    return infixExpr;
+}
+
+Expr* ASTSynthesizer::emitPrefixExpr(UnownedStringSlice operatorToken, Expr* base)
+{
+    auto prefixExpr = m_builder->create<PrefixExpr>();
+    prefixExpr->functionExpr = emitVarExpr(m_namePool->getName(operatorToken));;
+    prefixExpr->arguments.add(base);
+    return prefixExpr;
+}
+
+Expr* ASTSynthesizer::emitPostfixExpr(UnownedStringSlice operatorToken, Expr* base)
+{
+    auto postfixExpr = m_builder->create<PostfixExpr>();
+    postfixExpr->functionExpr = emitVarExpr(m_namePool->getName(operatorToken));;
+    postfixExpr->arguments.add(base);
+    return postfixExpr;
+}
+
+ForStmt* ASTSynthesizer::emitFor(Expr* initVal, Expr* finalVal, VarDecl* &outIndexVar)
+{
+    auto scopeDecl = pushVarScope()->containerDecl;
+    auto stmt = m_builder->create<ForStmt>();
+    stmt->scopeDecl = (ScopeDecl*)scopeDecl;
+    auto declStmt = emitVarDeclStmt(nullptr, m_namePool->getName("S_synth_loop_index"), initVal);
+    stmt->initialStatement = declStmt;
+    outIndexVar = (VarDecl*)declStmt->decl;
+    auto predicateExpr = emitBinaryExpr(UnownedStringSlice("<"), emitVarExpr(outIndexVar), finalVal);
+    stmt->predicateExpression = predicateExpr;
+    stmt->sideEffectExpression = emitPrefixExpr(UnownedStringSlice("++"), emitVarExpr(outIndexVar));
+    getCurrentScope().m_parentSeqStmt->stmts.add(stmt);
+    return stmt;
+}
+
+Expr* ASTSynthesizer::emitVarExpr(Name* name)
+{
+    auto scope = getCurrentScope();
+    SLANG_RELEASE_ASSERT(scope.m_scope);
+    auto varExpr = m_builder->create<VarExpr>();
+    varExpr->name = name;
+    varExpr->scope = scope.m_scope;
+    return varExpr;
+}
+
+Expr* ASTSynthesizer::emitVarExpr(VarDecl* varDecl)
+{
+    auto varExpr = m_builder->create<VarExpr>();
+    varExpr->declRef = makeDeclRef(varDecl);
+    varExpr->type = varDecl->type.type;
+    return varExpr;
+}
+
+Expr* ASTSynthesizer::emitVarExpr(VarDecl* var, Type* type)
+{
+    auto expr = m_builder->create<VarExpr>();
+    expr->declRef = DeclRef<Decl>(var, nullptr);
+    expr->type.type = type;
+    expr->type.isLeftValue = true;
+    return expr;
+}
+
+Expr* ASTSynthesizer::emitVarExpr(DeclStmt* varStmt, Type* type)
+{
+    auto expr = m_builder->create<VarExpr>();
+    expr->declRef = DeclRef<Decl>(as<Decl>(varStmt->decl), nullptr);
+    expr->type.type = type;
+    expr->type.isLeftValue = true;
+    return expr;
+}
+
+Expr* ASTSynthesizer::emitIntConst(int value)
+{
+    auto expr = m_builder->create<IntegerLiteralExpr>();
+    expr->type.type = m_builder->getIntType();
+    expr->value = value;
+    return expr;
+}
+
+Expr* ASTSynthesizer::emitGetArrayLengthExpr(Expr* arrayExpr)
+{
+    auto expr = m_builder->create<GetArrayLengthExpr>();
+    expr->arrayExpr = arrayExpr;
+    expr->type = m_builder->getIntType();
+    return expr;
+}
+
+Expr* ASTSynthesizer::emitMemberExpr(Expr* arrayExpr, Name* name)
+{
+    auto rs = m_builder->create<MemberExpr>();
+    rs->baseExpression = arrayExpr;
+    rs->name = name;
+    return rs;
+}
+
+Expr* ASTSynthesizer::emitAssignExpr(Expr* left, Expr* right)
+{
+    auto rs = m_builder->create<AssignExpr>();
+    rs->left = left;
+    rs->right = right;
+    return rs;
+}
+
+Expr* ASTSynthesizer::emitInvokeExpr(Expr* callee, List<Expr*>&& args)
+{
+    auto rs = m_builder->create<InvokeExpr>();
+    rs->functionExpr = callee;
+    rs->arguments = _Move(args);
+    return rs;
+}
+
+Expr* ASTSynthesizer::emitMemberExpr(Type* type, Name* name)
+{
+    auto rs = m_builder->create<StaticMemberExpr>();
+    auto typeExpr = m_builder->create<SharedTypeExpr>();
+    auto typetype = m_builder->create<TypeType>();
+    typetype->type = type;
+    typeExpr->type = typetype;
+    rs->baseExpression = typeExpr;
+    rs->name = name;
+    return rs;
+}
+
+Expr* ASTSynthesizer::emitIndexExpr(Expr* base, Expr* index)
+{
+    auto rs = m_builder->create<IndexExpr>();
+    rs->baseExpression = base;
+    rs->indexExprs.add(index);
+    return rs;
+}
+
+ExpressionStmt* ASTSynthesizer::emitExprStmt(Expr* expr)
+{
+    auto rs = m_builder->create<ExpressionStmt>();
+    _addStmtToScope(rs);
+    rs->expression = expr;
+    return rs;
+}
+
+ReturnStmt* ASTSynthesizer::emitReturnStmt(Expr* expr)
+{
+    auto rs = m_builder->create<ReturnStmt>();
+    rs->expression = expr;
+    _addStmtToScope(rs);
+    return rs;
+}
+
+DeclStmt* ASTSynthesizer::emitVarDeclStmt(Type* type, Name* name, Expr* initVal)
+{
+    auto scope = getCurrentScope();
+    SLANG_RELEASE_ASSERT(scope.m_parentSeqStmt);
+    SLANG_RELEASE_ASSERT(scope.m_scope);
+    SLANG_RELEASE_ASSERT(scope.m_scope->containerDecl);
+    auto varDecl = m_builder->create<VarDecl>();
+    varDecl->type.type = type;
+    varDecl->nameAndLoc.name = name;
+    varDecl->initExpr = initVal;
+    varDecl->parentDecl = scope.m_scope->containerDecl;
+    varDecl->parentDecl->members.add(varDecl);
+    auto stmt = m_builder->create<DeclStmt>();
+    stmt->decl = varDecl;
+    _addStmtToScope(stmt);
+    return stmt;
+}
+
+}
-- 
cgit v1.2.3