LCOV - code coverage report
Current view: top level - inc/visitors/fillSemanticInfo - fillSemanticInfo.h (source / functions) Coverage Total Hit
Test: coverage.info Lines: 0.0 % 8 0
Test Date: 2025-04-18 15:53:49 Functions: 0.0 % 3 0

            Line data    Source code
       1              : #ifndef FILL_SEMANTIC_INFO_H
       2              : #define FILL_SEMANTIC_INFO_H
       3              : 
       4              : #include "../../tables/functionTable/functionTable.h"
       5              : #include "../../tables/scope/scope.h"
       6              : #include "../../tables/typeTable/typeTable.h"
       7              : #include "../visitor.h"
       8              : #include <memory>
       9              : #include <unordered_set>
      10              : #include "../../options/options.h"
      11              : #include <variant>
      12              : #include <vector>
      13              : 
      14              : namespace nicole {
      15              : 
      16              : class FillSemanticInfo final : public Visitor<std::monostate> {
      17              : private:
      18              :   mutable std::shared_ptr<FunctionTable> functionTable_;
      19              :   mutable std::shared_ptr<TypeTable> typeTable_;
      20              :   Options options_;
      21              : 
      22              :   mutable std::shared_ptr<Scope> currentScope_{nullptr};
      23              :   mutable std::shared_ptr<Scope> firstScope_{nullptr};
      24              :   mutable std::vector<GenericParameter> currentGenericList_{};
      25              :   mutable std::vector<GenericParameter> currentStructGenericList_{};
      26              :   mutable std::shared_ptr<UserType> currentUserType_{nullptr};
      27              :   mutable bool analyzingInsideClass{false};
      28              : 
      29              :   void pushScope() const noexcept;
      30              : 
      31              :   void popScope() const noexcept;
      32              : 
      33              :   [[nodiscard]] std::expected<std::vector<GenericParameter>, Error>
      34              :   mergeGenericLists(const std::vector<GenericParameter> &list1,
      35              :                     const std::vector<GenericParameter> &list2) const noexcept;
      36              : 
      37              :   [[nodiscard]] bool hasDuplicatedGenerics(
      38              :       const std::vector<GenericParameter> &list) const noexcept;
      39              : 
      40              :   [[nodiscard]] bool
      41              :   areAmbiguousFunctions(const Function &first,
      42              :                         const Function &second) const noexcept;
      43              : 
      44              :   [[nodiscard]] bool areAmbiguousMethods(const Method &first,
      45              :                                          const Method &second) const noexcept;
      46              : 
      47              : public:
      48              :   FillSemanticInfo(const std::shared_ptr<FunctionTable> &functionTable,
      49              :                    std::shared_ptr<TypeTable> &typeTable,
      50              :                    const Options& options) noexcept
      51            0 :       : functionTable_{functionTable}, typeTable_{typeTable},
      52            0 :         options_{options} {}
      53              : 
      54            0 :   [[nodiscard]] const std::shared_ptr<Scope> getGlobalScope() const noexcept {
      55            0 :     return firstScope_;
      56            0 :   }
      57              : 
      58              :   [[nodiscard]] std::expected<std::monostate, Error>
      59              :   visit(const AST_BOOL *node) const noexcept override;
      60              : 
      61              :   [[nodiscard]] std::expected<std::monostate, Error>
      62              :   visit(const AST_CHAR *node) const noexcept override;
      63              : 
      64              :   [[nodiscard]] std::expected<std::monostate, Error>
      65              :   visit(const AST_DOUBLE *node) const noexcept override;
      66              : 
      67              :   [[nodiscard]] std::expected<std::monostate, Error>
      68              :   visit(const AST_FLOAT *node) const noexcept override;
      69              : 
      70              :   [[nodiscard]] std::expected<std::monostate, Error>
      71              :   visit(const AST_INT *node) const noexcept override;
      72              : 
      73              :   [[nodiscard]] std::expected<std::monostate, Error>
      74              :   visit(const AST_NULL *node) const noexcept override;
      75              : 
      76              :   [[nodiscard]] std::expected<std::monostate, Error>
      77              :   visit(const AST_STRING *node) const noexcept override;
      78              : 
      79              :   [[nodiscard]] std::expected<std::monostate, Error>
      80              :   visit(const AST_VECTOR *node) const noexcept override;
      81              : 
      82              :   [[nodiscard]] std::expected<std::monostate, Error>
      83              :   visit(const AST_INDEX *node) const noexcept override;
      84              : 
      85              :   [[nodiscard]] std::expected<std::monostate, Error>
      86              :   visit(const AST_DELETE *node) const noexcept override;
      87              : 
      88              :   [[nodiscard]] std::expected<std::monostate, Error>
      89              :   visit(const AST_NEW *node) const noexcept override;
      90              : 
      91              :   [[nodiscard]] std::expected<std::monostate, Error>
      92              :   visit(const AST_DEREF *node) const noexcept override;
      93              : 
      94              :   [[nodiscard]] std::expected<std::monostate, Error>
      95              :   visit(const AST_BINARY *node) const noexcept override;
      96              : 
      97              :   [[nodiscard]] std::expected<std::monostate, Error>
      98              :   visit(const AST_UNARY *node) const noexcept override;
      99              : 
     100              :   [[nodiscard]] std::expected<std::monostate, Error>
     101              :   visit(const AST_ASSIGNMENT *node) const noexcept override;
     102              : 
     103              :   [[nodiscard]] std::expected<std::monostate, Error>
     104              :   visit(const AST_PRINT *node) const noexcept override;
     105              : 
     106              :   [[nodiscard]] std::expected<std::monostate, Error>
     107              :   visit(const AST_IMPORT *node) const noexcept override;
     108              : 
     109              :   [[nodiscard]] std::expected<std::monostate, Error>
     110              :   visit(const AST_STATEMENT *node) const noexcept override;
     111              : 
     112              :   [[nodiscard]] std::expected<std::monostate, Error>
     113              :   visit(const AST_BODY *node) const noexcept override;
     114              : 
     115              :   [[nodiscard]] std::expected<std::monostate, Error>
     116              :   visit(const AST_WHILE *node) const noexcept override;
     117              : 
     118              :   [[nodiscard]] std::expected<std::monostate, Error>
     119              :   visit(const AST_FOR *node) const noexcept override;
     120              : 
     121              :   [[nodiscard]] std::expected<std::monostate, Error>
     122              :   visit(const AST_DO_WHILE *node) const noexcept override;
     123              : 
     124              :   [[nodiscard]] std::expected<std::monostate, Error>
     125              :   visit(const AST_PASS *node) const noexcept override;
     126              : 
     127              :   [[nodiscard]] std::expected<std::monostate, Error>
     128              :   visit(const AST_STOP *node) const noexcept override;
     129              : 
     130              :   [[nodiscard]] std::expected<std::monostate, Error>
     131              :   visit(const AST_IF *node) const noexcept override;
     132              : 
     133              :   [[nodiscard]] std::expected<std::monostate, Error>
     134              :   visit(const AST_ELSE_IF *node) const noexcept override;
     135              : 
     136              :   [[nodiscard]] std::expected<std::monostate, Error>
     137              :   visit(const AST_SWITCH *node) const noexcept override;
     138              : 
     139              :   [[nodiscard]] std::expected<std::monostate, Error>
     140              :   visit(const AST_CASE *node) const noexcept override;
     141              : 
     142              :   [[nodiscard]] std::expected<std::monostate, Error>
     143              :   visit(const AST_DEFAULT *node) const noexcept override;
     144              : 
     145              :   [[nodiscard]] std::expected<std::monostate, Error>
     146              :   visit(const AST_TERNARY *node) const noexcept override;
     147              : 
     148              :   [[nodiscard]] std::expected<std::monostate, Error>
     149              :   visit(const AST_CONDITION *node) const noexcept override;
     150              : 
     151              :   [[nodiscard]] std::expected<std::monostate, Error>
     152              :   visit(const AST_FUNC_CALL *node) const noexcept override;
     153              : 
     154              :   [[nodiscard]] std::expected<std::monostate, Error>
     155              :   visit(const AST_FUNC_DECL *node) const noexcept override;
     156              : 
     157              :   [[nodiscard]] std::expected<std::monostate, Error>
     158              :   visit(const AST_RETURN *node) const noexcept override;
     159              : 
     160              :   [[nodiscard]] std::expected<std::monostate, Error>
     161              :   visit(const AST_ENUM *node) const noexcept override;
     162              : 
     163              :   [[nodiscard]] std::expected<std::monostate, Error>
     164              :   visit(const AST_ENUM_ACCESS *node) const noexcept override;
     165              : 
     166              :   [[nodiscard]] std::expected<std::monostate, Error>
     167              :   visit(const AST_STRUCT *node) const noexcept override;
     168              : 
     169              :   [[nodiscard]] std::expected<std::monostate, Error>
     170              :   visit(const AST_ATTR_ACCESS *node) const noexcept override;
     171              : 
     172              :   [[nodiscard]] std::expected<std::monostate, Error>
     173              :   visit(const AST_METHOD_CALL *node) const noexcept override;
     174              : 
     175              :   [[nodiscard]] std::expected<std::monostate, Error>
     176              :   visit(const AST_METHOD_DECL *node) const noexcept override;
     177              : 
     178              :   [[nodiscard]] std::expected<std::monostate, Error>
     179              :   visit(const AST_CONSTRUCTOR_DECL *node) const noexcept override;
     180              : 
     181              :   [[nodiscard]] std::expected<std::monostate, Error>
     182              :   visit(const AST_SUPER *node) const noexcept override;
     183              : 
     184              :   [[nodiscard]] std::expected<std::monostate, Error>
     185              :   visit(const AST_DESTRUCTOR_DECL *node) const noexcept override;
     186              : 
     187              :   [[nodiscard]] std::expected<std::monostate, Error>
     188              :   visit(const AST_THIS *node) const noexcept override;
     189              : 
     190              :   [[nodiscard]] std::expected<std::monostate, Error>
     191              :   visit(const AST_CONSTRUCTOR_CALL *node) const noexcept override;
     192              : 
     193              :   [[nodiscard]] std::expected<std::monostate, Error>
     194              :   visit(const AST_AUTO_DECL *node) const noexcept override;
     195              : 
     196              :   [[nodiscard]] std::expected<std::monostate, Error>
     197              :   visit(const AST_VAR_TYPED_DECL *node) const noexcept override;
     198              : 
     199              :   [[nodiscard]] std::expected<std::monostate, Error>
     200              :   visit(const AST_VAR_CALL *node) const noexcept override;
     201              : 
     202              :   [[nodiscard]] std::expected<std::monostate, Error>
     203              :   visit(const AST_CHAINED *node) const noexcept override;
     204              : 
     205              :   [[nodiscard]] std::expected<std::monostate, Error>
     206              :   visit(const Tree *tree) const noexcept override;
     207              : 
     208              :   [[nodiscard]] std::expected<std::monostate, Error>
     209            0 :   fill(const Tree *tree) const noexcept {
     210            0 :     return visit(tree);
     211            0 :   }
     212              : };
     213              : 
     214              : } // namespace nicole
     215              : 
     216              : #endif
        

Generated by: LCOV version 2.0-1