undoAppSTSemantic.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ast/AST.h"
#include "semantic/SymbolTable.h"
 
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace undoApp {
namespace ST {
 
enum class SymCategory
{
   Unresolved, 
   Variable,
   Constant,   
   Parameter,
   Function,   
   Type,       
   Field,      
   Enumerator
};
 
struct SemanticToken
{
   int line = 0;              
   int col = 0;               
   int length = 0;            
   SymCategory category = SymCategory::Unresolved;
};
 
struct SemanticTokenSet
{
   std::vector<SemanticToken> tokens;
};
 
SemanticTokenSet collectSemanticTokens(const TranslationUnit& tu,
                                       const st2cpp::semantic::SymbolTable& symTab,
                                       const std::vector<std::string>& srcLines);
 
st2cpp::semantic::ScopeId findMemberScopeFor(const st2cpp::semantic::SymbolTable& symTab,
                                             const std::string& ownerName,
                                             bool method);
 
std::string describeType(const TypeRef& type);
 
struct Declaration
{
   int line = 0;         
   int col = 0;          
   std::string name;     
   int ownerLine = 0;    
   std::string scope;    
   SymCategory category = SymCategory::Unresolved;
   std::string typeText; 
   std::string kindText; 
};
 
using DeclarationIndex = std::unordered_map<std::string, std::vector<Declaration>>;
 
DeclarationIndex collectDeclarations(const TranslationUnit& tu,
                                     const st2cpp::semantic::SymbolTable& symTab);
 
// ============================================================================
//  Member access
//
//  What the '.' operator can reach on a value: the call interface, the
//  internal state and the methods of a function block, inheritance included.
// ============================================================================
 
struct NameMatch
{
   bool matched = false;            
   int score = 0;                   
   std::vector<int> positions;      
};
 
NameMatch matchName(const std::string& name, const std::string& pattern);
 
struct Suggestion
{
   enum class Kind
   {
      Parameter,  
      State,      
      Method,     
      Constant,   
      Function,   
      Block,      
      Type,       
      Enumerator  
   };
 
   std::string name;       
   std::string typeText;   
   Kind kind = Kind::State;
   bool isConstant = false;
   bool isRetain = false;
   bool isAbstract = false;
   bool isOverride = false;
   bool inherited = false;  
   std::string declaredIn;  
   std::vector<std::string> parameterTypes; 
   std::vector<std::string> parameterNames; 
   std::vector<std::string> parameterDirs;  
   std::string note;                        
 
   bool matches(const std::string& prefix) const;
 
   std::vector<int> matchPositions;
};
 
using MemberAccess = Suggestion;
using MemberList = std::vector<Suggestion>;
 
void rankMembers(MemberList& members, const std::string& pattern);
 
MemberList collectBlockMembers(const st2cpp::semantic::SymbolTable& symTab,
                               st2cpp::semantic::SymbolId fbId);
 
st2cpp::semantic::SymbolId findInstanceBlock(const st2cpp::semantic::SymbolTable& symTab,
                                             st2cpp::semantic::ScopeId scopeId,
                                             const std::string& name);
 
struct MemberAccessPoint
{
   bool active = false;     
   std::string objectName;  
   std::string prefix;      
   int dotColumn = -1;      
};
 
MemberAccessPoint memberAccessPointAt(const std::string& line, int cursorCol);
 
std::string describeMember(const Suggestion& member);
 
MemberList collectScopeNames(const st2cpp::semantic::SymbolTable& symTab,
                            st2cpp::semantic::ScopeId scopeId,
                            bool includeOwnMethods = true);
 
// ============================================================================
//  Call sites and signature help
//
//  What a call looks like from the inside: the callee, the argument the cursor
//  sits in, and the parameter list to show while it is being typed.
// ============================================================================
 
struct CallSite
{
   bool active = false;        
   std::string objectName;     
   std::string calleeName;     
   std::string label;          
   int argumentIndex = 0;      
   int parenLine = -1;         
   int parenColumn = -1;       
   int argumentLine = -1;      
   int argumentColumn = -1;    
};
 
CallSite callSiteAt(const std::vector<std::string>& lines, int line, int col);
 
struct SignatureParam
{
   std::string name;         
   std::string type;         
   std::string direction;    
   bool hasDefault = false;  
};
 
struct CallSignature
{
   std::string name;      
   std::string owner;     
   std::string returnType;
   bool inherited = false;
   std::string declaredIn;
   std::vector<SignatureParam> params;
};
 
bool resolveCallSignature(const st2cpp::semantic::SymbolTable& symTab,
                          st2cpp::semantic::ScopeId scopeId,
                          const CallSite& call,
                          CallSignature& out);
 
struct SignatureSegment
{
   std::string text;
   bool isParameter = false; 
};
 
std::vector<SignatureSegment> signatureSegments(const CallSignature& signature, int activeArgument);
 
std::string formatSignature(const CallSignature& signature, int activeArgument);
 
} // namespace ST
} // namespace undoApp