Move the SemanticModel class to the tests folder; it's not really pro…

…duction quality
MikePopoloski · Mar 22, 2024 · 1869b93 · 1869b93
1 parent de48f5e
commit 1869b93
Show file tree

Hide file tree

Showing 4 changed files with 112 additions and 172 deletions.
diff --git a/include/slang/ast/SemanticModel.h b/include/slang/ast/SemanticModel.h
diff --git a/source/ast/CMakeLists.txt b/source/ast/CMakeLists.txt
@@ -59,7 +59,6 @@ target_sources(
           Scope.cpp
           ScriptSession.cpp
           SemanticFacts.cpp
-          SemanticModel.cpp
           SFormat.cpp
           Statements.cpp
           Symbol.cpp

diff --git a/source/ast/SemanticModel.cpp b/source/ast/SemanticModel.cpp
diff --git a/tests/unittests/parsing/VisitorTests.cpp b/tests/unittests/parsing/VisitorTests.cpp
@@ -5,11 +5,122 @@
 #include <fmt/core.h>
 
 #include "slang/ast/ASTVisitor.h"
-#include "slang/ast/SemanticModel.h"
 #include "slang/parsing/ParserMetadata.h"
 #include "slang/syntax/SyntaxPrinter.h"
 #include "slang/syntax/SyntaxVisitor.h"
 
+class SemanticModel {
+public:
+    explicit SemanticModel(Compilation& compilation) : compilation(compilation) {}
+
+    const Symbol* getDeclaredSymbol(const syntax::SyntaxNode& syntax) {
+        // If we've already cached this node, return that.
+        if (auto it = symbolCache.find(&syntax); it != symbolCache.end())
+            return it->second;
+
+        // If we hit the top of the syntax tree, look in the compilation for the correct symbol.
+        if (syntax.kind == SyntaxKind::CompilationUnit) {
+            auto result = compilation.getCompilationUnit(syntax.as<CompilationUnitSyntax>());
+            if (result)
+                symbolCache[&syntax] = result;
+            return result;
+        }
+        else if (syntax.kind == SyntaxKind::ModuleDeclaration ||
+                 syntax.kind == SyntaxKind::InterfaceDeclaration ||
+                 syntax.kind == SyntaxKind::ProgramDeclaration) {
+            auto def = compilation.getDefinition(syntax.as<ModuleDeclarationSyntax>());
+            if (!def)
+                return nullptr;
+
+            // There is no symbol to use here so create a placeholder instance.
+            auto result = &InstanceSymbol::createDefault(compilation, *def);
+            symbolCache[&syntax] = result;
+            return result;
+        }
+
+        // Otherwise try to find the parent symbol first.
+        auto parent = syntax.parent ? getDeclaredSymbol(*syntax.parent) : nullptr;
+        if (!parent)
+            return nullptr;
+
+        // If this is a type alias, unwrap its target type to look at the syntax node.
+        if (parent->kind == SymbolKind::TypeAlias) {
+            auto& target = parent->as<TypeAliasType>().targetType.getType();
+            if (target.getSyntax() == &syntax) {
+                symbolCache.emplace(&syntax, &target);
+                return &target;
+            }
+            return nullptr;
+        }
+
+        if (parent->kind == SymbolKind::Instance)
+            parent = &parent->as<InstanceSymbol>().body;
+        else if (!parent->isScope())
+            return nullptr;
+
+        // Search among the parent's children to see if we can find ourself.
+        for (auto& child : parent->as<Scope>().members()) {
+            if (child.getSyntax() == &syntax) {
+                // We found ourselves, hurray.
+                symbolCache.emplace(&syntax, &child);
+                return &child;
+            }
+        }
+
+        return nullptr;
+    }
+
+    const CompilationUnitSymbol* getDeclaredSymbol(const CompilationUnitSyntax& syntax) {
+        auto result = getDeclaredSymbol((const SyntaxNode&)syntax);
+        return result ? &result->as<CompilationUnitSymbol>() : nullptr;
+    }
+
+    const InstanceSymbol* getDeclaredSymbol(const HierarchyInstantiationSyntax& syntax) {
+        auto result = getDeclaredSymbol((const SyntaxNode&)syntax);
+        return result ? &result->as<InstanceSymbol>() : nullptr;
+    }
+
+    const StatementBlockSymbol* getDeclaredSymbol(const BlockStatementSyntax& syntax) {
+        auto result = getDeclaredSymbol((const SyntaxNode&)syntax);
+        return result ? &result->as<StatementBlockSymbol>() : nullptr;
+    }
+
+    const ProceduralBlockSymbol* getDeclaredSymbol(const ProceduralBlockSyntax& syntax) {
+        auto result = getDeclaredSymbol((const SyntaxNode&)syntax);
+        return result ? &result->as<ProceduralBlockSymbol>() : nullptr;
+    }
+
+    const GenerateBlockSymbol* getDeclaredSymbol(const IfGenerateSyntax& syntax) {
+        auto result = getDeclaredSymbol((const SyntaxNode&)syntax);
+        return result ? &result->as<GenerateBlockSymbol>() : nullptr;
+    }
+
+    const GenerateBlockArraySymbol* getDeclaredSymbol(const LoopGenerateSyntax& syntax) {
+        auto result = getDeclaredSymbol((const SyntaxNode&)syntax);
+        return result ? &result->as<GenerateBlockArraySymbol>() : nullptr;
+    }
+
+    const SubroutineSymbol* getDeclaredSymbol(const FunctionDeclarationSyntax& syntax) {
+        auto result = getDeclaredSymbol((const SyntaxNode&)syntax);
+        return result ? &result->as<SubroutineSymbol>() : nullptr;
+    }
+
+    const EnumType* getDeclaredSymbol(const EnumTypeSyntax& syntax) {
+        auto result = getDeclaredSymbol((const SyntaxNode&)syntax);
+        return result ? &result->as<EnumType>() : nullptr;
+    }
+
+    const TypeAliasType* getDeclaredSymbol(const TypedefDeclarationSyntax& syntax) {
+        auto result = getDeclaredSymbol((const SyntaxNode&)syntax);
+        return result ? &result->as<TypeAliasType>() : nullptr;
+    }
+
+private:
+    Compilation& compilation;
+
+    flat_hash_map<const syntax::SyntaxNode*, const Symbol*> symbolCache;
+};
+
 class TestRewriter : public SyntaxRewriter<TestRewriter> {
 public:
     Compilation compilation;