refactor(semantic): rewrite TemplateResolver without Sema

src/compile/compilation.cpp

@@ -320,8 +320,8 @@ CompilationStatus CompilationUnitRef::Self::run_clang(
 
     self.run_tidy();
 
-    if(instance.hasSema()) {
-        self.resolver.emplace(instance.getSema());
+    if(instance.hasASTContext()) {
+        self.resolver.emplace(instance.getASTContext());
     }
 
     return CompilationStatus::Completed;

src/feature/hover.cpp

@@ -1140,7 +1140,7 @@ auto decls_at(CompilationUnitRef unit, llvm::ArrayRef<clang::syntax::Token> touc
                     continue;
                 }
 
-                for(auto& occurrence: resolve_occurrences(sem_node, &unit.resolver())) {
+                for(auto& occurrence: resolve_occurrences(semantics, n, &unit.resolver())) {
                     auto location = occurrence.location;
                     if(location.isMacroID()) {
                         location = unit.spelling_location(location);

src/feature/semantic_tokens.cpp

@@ -444,7 +444,7 @@ class SemanticTokensCollector {
                 combine(token_semantics[index], candidate);
             };
 
-        for(const auto& entry: semantics.node_entries()) {
+        for(auto [entry_index, entry]: llvm::enumerate(semantics.node_entries())) {
             const SemanticNode& node = entry.node;
             switch(node.kind()) {
                 case SemanticNode::Kind::MacroDefine: {
@@ -486,7 +486,10 @@ class SemanticTokensCollector {
                 }
 
                 default: {
-                    for(auto& occurrence: resolve_occurrences(node, &unit.resolver())) {
+                    for(auto& occurrence:
+                        resolve_occurrences(semantics,
+                                            static_cast<std::uint32_t>(entry_index),
+                                            &unit.resolver())) {
                         anchor(occurrence.location,
                                classify_decl(occurrence.decl, occurrence.kind),
                                false);

src/index/tu_index.cpp

@@ -527,7 +527,7 @@ class Projector {
                 continue;
             }
 
-            for(auto& occurrence: resolve_occurrences(node, &unit.resolver())) {
+            for(auto& occurrence: resolve_occurrences(semantics, i, &unit.resolver())) {
                 add_occurrence(occurrence.decl, occurrence.kind, occurrence.location);
 
                 /// Every occurrence is mirrored as a self-relation, so

src/semantic/resolver.h

@@ -3,12 +3,6 @@
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/Type.h"
 
-namespace clang {
-
-class Sema;
-
-}
-
 namespace clice {
 
 /// This class is used to resolve dependent names in the unit.
@@ -18,26 +12,18 @@ namespace clice {
 /// some heuristics to simplify the dependent names as normal type/expression.
 /// For example, `std::vector<T>::value_type` can be simplified as `T`.
 ///
+/// Resolution is pure AST computation: it never enters Sema, so speculative
+/// lookups cannot emit diagnostics, register specializations, or otherwise
+/// mutate the unit's semantic state.
+///
 /// Thread safety: NOT thread-safe. Each compilation unit should have its own resolver.
 /// The `resolved` cache persists across multiple resolve() calls on the same unit.
 class TemplateResolver {
 public:
-    explicit TemplateResolver(clang::Sema& sema) : sema(sema) {}
+    explicit TemplateResolver(clang::ASTContext& context) : context(context) {}
 
     clang::QualType resolve(clang::QualType type);
 
-    void resolve(clang::CXXUnresolvedConstructExpr* expr);
-
-    void resolve(clang::UnresolvedLookupExpr* expr);
-
-    // TODO: Use a clearer approach for resolving UnresolvedLookupExpr.
-
-    void resolve(clang::UnresolvedUsingType* type);
-
-    /// Resugar the canonical `TemplateTypeParmType` with given template context.
-    /// `decl` should be the declaration that the type is in.
-    clang::QualType resugar(clang::QualType type, clang::Decl* decl);
-
     using lookup_result = clang::DeclContext::lookup_result;
 
     /// Look up the name in the given nested name specifier.
@@ -47,35 +33,25 @@ class TemplateResolver {
         return lookup(type->getQualifier(), type->getIdentifier());
     }
 
-    lookup_result lookup(const clang::DependentTemplateSpecializationType* type) {
-        auto& template_name = type->getDependentTemplateName();
-        auto identifier = template_name.getName().getIdentifier();
-        if(identifier) {
-            return lookup(template_name.getQualifier(), identifier);
-        } else {
-            /// TODO: Operators don't have an IdentifierInfo; need DeclarationName-based lookup.
-            return {};
-        }
-    }
+    lookup_result lookup(const clang::DependentTemplateSpecializationType* type);
 
     lookup_result lookup(const clang::DependentScopeDeclRefExpr* expr) {
         return lookup(expr->getQualifier(), expr->getNameInfo().getName());
     }
 
-    lookup_result lookup(const clang::UnresolvedLookupExpr* expr) {
-        /// TODO: Only returns the first TemplateDecl; should handle overloaded lookups.
-        for(auto decl: expr->decls()) {
-            if(auto TD = llvm::dyn_cast<clang::TemplateDecl>(decl)) {
-                return lookup_result(TD);
-            }
-        }
+    lookup_result lookup(const clang::UnresolvedLookupExpr* expr);
 
-        return {};
-    }
+    /// Resolve the base type through pseudo-instantiation, then look the
+    /// member up in the resolved record. Complements the candidates clang
+    /// already stores on the expression: pseudo-instantiation can reach
+    /// members of matching partial specializations.
+    lookup_result lookup(const clang::UnresolvedMemberExpr* expr);
 
-    lookup_result lookup(const clang::UnresolvedMemberExpr* expr) {
-        return {};
-    }
+    /// Resolve a dependent call's candidate set, filtered down to overloads
+    /// whose parameter list can accept the call's argument count. Full
+    /// overload resolution needs conversion rules (Sema territory); arity is
+    /// the safe, conversion-free subset of it.
+    llvm::SmallVector<clang::NamedDecl*, 4> lookup(const clang::CallExpr* expr);
 
     /// Resolve the base type through pseudo-instantiation, then look the
     /// member up in the resolved record (e.g. `this->foo()` inherited from
@@ -91,7 +67,7 @@ class TemplateResolver {
     }
 
 private:
-    clang::Sema& sema;
+    clang::ASTContext& context;
 
     /// Cache of resolved dependent types, keyed by AST node pointer.
     /// Shared across resolve() calls within the same TU for performance.

src/semantic/semantics.cpp

@@ -1334,7 +1334,10 @@ clang::SourceLocation keyword_after_scope(const clang::Decl* decl,
     return token ? token->getLocation() : begin;
 }
 
-void stmt_occurrences(const clang::Stmt* S, Occurrences& out, TemplateResolver* resolver) {
+void stmt_occurrences(const clang::Stmt* S,
+                      Occurrences& out,
+                      TemplateResolver* resolver,
+                      const clang::CallExpr* call = nullptr) {
     /// foo = 1
     ///  ^~~~ reference
     if(auto* DRE = llvm::dyn_cast<clang::DeclRefExpr>(S)) {
@@ -1444,8 +1447,14 @@ void stmt_occurrences(const clang::Stmt* S, Occurrences& out, TemplateResolver*
     ///                       ^~~~ weak reference
     if(auto* DSDRE = llvm::dyn_cast<clang::DependentScopeDeclRefExpr>(S)) {
         if(resolver) {
-            for(auto* target: resolver->lookup(DSDRE)) {
-                occur(out, target, RelationKind::WeakReference, DSDRE->getNameInfo().getLoc());
+            if(call) {
+                for(auto* target: resolver->lookup(call)) {
+                    occur(out, target, RelationKind::WeakReference, DSDRE->getNameInfo().getLoc());
+                }
+            } else {
+                for(auto* target: resolver->lookup(DSDRE)) {
+                    occur(out, target, RelationKind::WeakReference, DSDRE->getNameInfo().getLoc());
+                }
             }
         }
         return;
@@ -1454,11 +1463,20 @@ void stmt_occurrences(const clang::Stmt* S, Occurrences& out, TemplateResolver*
     /// foo(...) / obj.foo(...) where foo names an overload set — clang
     /// already stores the candidates.
     if(auto* OE = llvm::dyn_cast<clang::OverloadExpr>(S)) {
+        /// As a callee, the candidate set shrinks to the overloads that can
+        /// accept the call's argument count.
+        llvm::SmallVector<clang::NamedDecl*, 4> candidates;
+        if(call && resolver) {
+            candidates = resolver->lookup(call);
+        } else {
+            candidates.append(OE->decls_begin(), OE->decls_end());
+        }
+
         /// Unwrap using shadows to the underlying functions, then reference
         /// each introducing using-declaration once: hover picks it when the
         /// overload set is otherwise ambiguous.
         llvm::SmallPtrSet<const clang::UsingDecl*, 2> introducers;
-        for(auto* target: OE->decls()) {
+        for(auto* target: candidates) {
             if(auto* shadow = llvm::dyn_cast<clang::UsingShadowDecl>(target)) {
                 if(auto* UD = llvm::dyn_cast<clang::UsingDecl>(shadow->getIntroducer())) {
                     introducers.insert(UD);
@@ -1494,8 +1512,14 @@ void stmt_occurrences(const clang::Stmt* S, Occurrences& out, TemplateResolver*
     ///   ^~~~ weak reference, resolved through the template resolver
     if(auto* DSME = llvm::dyn_cast<clang::CXXDependentScopeMemberExpr>(S)) {
         if(resolver) {
-            for(auto* target: resolver->lookup(DSME)) {
-                occur(out, target, RelationKind::WeakReference, DSME->getMemberLoc());
+            if(call) {
+                for(auto* target: resolver->lookup(call)) {
+                    occur(out, target, RelationKind::WeakReference, DSME->getMemberLoc());
+                }
+            } else {
+                for(auto* target: resolver->lookup(DSME)) {
+                    occur(out, target, RelationKind::WeakReference, DSME->getMemberLoc());
+                }
             }
         }
         return;
@@ -1504,6 +1528,41 @@ void stmt_occurrences(const clang::Stmt* S, Occurrences& out, TemplateResolver*
 
 }  // namespace
 
+llvm::SmallVector<NameOccurrence, 2> resolve_occurrences(const Semantics& semantics,
+                                                         std::uint32_t index,
+                                                         TemplateResolver* resolver) {
+    auto& entry = semantics.node(index);
+
+    /// A dependent name used as a callee resolves against the call, so the
+    /// candidate set can be filtered by arity. Walk up through the wrapper
+    /// nodes the tree keeps for parent chains.
+    if(auto* S = entry.node.get<clang::Stmt>();
+       S && llvm::isa<clang::OverloadExpr,
+                      clang::DependentScopeDeclRefExpr,
+                      clang::CXXDependentScopeMemberExpr>(S)) {
+        for(auto parent = entry.parent; parent != Semantics::invalid;
+            parent = semantics.node(parent).parent) {
+            auto* PS = semantics.node(parent).node.get<clang::Stmt>();
+            if(!PS) {
+                break;
+            }
+            if(auto* CE = llvm::dyn_cast<clang::CallExpr>(PS)) {
+                if(CE->getCallee()->IgnoreParenImpCasts() == S) {
+                    llvm::SmallVector<NameOccurrence, 2> out;
+                    stmt_occurrences(S, out, resolver, CE);
+                    return out;
+                }
+                break;
+            }
+            if(!llvm::isa<clang::ParenExpr, clang::ImplicitCastExpr>(PS)) {
+                break;
+            }
+        }
+    }
+
+    return resolve_occurrences(entry.node, resolver);
+}
+
 llvm::SmallVector<NameOccurrence, 2> resolve_occurrences(const SemanticNode& node,
                                                          TemplateResolver* resolver) {
     llvm::SmallVector<NameOccurrence, 2> out;

src/semantic/semantics.h

@@ -318,4 +318,11 @@ class Semantics {
     std::vector<std::uint32_t> owner_nodes;
 };
 
+/// resolve_occurrences with tree context: a dependent name that is the
+/// callee of a call (found through the node's parent chain) has its
+/// candidate set filtered by the call's arity.
+llvm::SmallVector<NameOccurrence, 2> resolve_occurrences(const Semantics& semantics,
+                                                         std::uint32_t index,
+                                                         TemplateResolver* resolver = nullptr);
+
 }  // namespace clice