89011ff3b95657e422bed27b4c24f16391e98017
[lldb.git] / flang / lib / Semantics / resolve-names-utils.h
1 //===-- lib/Semantics/resolve-names-utils.h ---------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #ifndef FORTRAN_SEMANTICS_RESOLVE_NAMES_UTILS_H_
10 #define FORTRAN_SEMANTICS_RESOLVE_NAMES_UTILS_H_
11
12 // Utility functions and class for use in resolve-names.cpp.
13
14 #include "flang/Evaluate/fold.h"
15 #include "flang/Parser/message.h"
16 #include "flang/Parser/tools.h"
17 #include "flang/Semantics/expression.h"
18 #include "flang/Semantics/scope.h"
19 #include "flang/Semantics/semantics.h"
20 #include "flang/Semantics/symbol.h"
21 #include "flang/Semantics/type.h"
22 #include "llvm/Support/raw_ostream.h"
23 #include <forward_list>
24
25 namespace Fortran::parser {
26 class CharBlock;
27 struct ArraySpec;
28 struct CoarraySpec;
29 struct ComponentArraySpec;
30 struct DataRef;
31 struct DefinedOpName;
32 struct Designator;
33 struct Expr;
34 struct GenericSpec;
35 struct Name;
36 } // namespace Fortran::parser
37
38 namespace Fortran::semantics {
39
40 using SourceName = parser::CharBlock;
41 class SemanticsContext;
42
43 // Record that a Name has been resolved to a Symbol
44 Symbol &Resolve(const parser::Name &, Symbol &);
45 Symbol *Resolve(const parser::Name &, Symbol *);
46
47 // Create a copy of msg with a new isFatal value.
48 parser::MessageFixedText WithIsFatal(
49     const parser::MessageFixedText &msg, bool isFatal);
50
51 bool IsIntrinsicOperator(const SemanticsContext &, const SourceName &);
52 bool IsLogicalConstant(const SemanticsContext &, const SourceName &);
53
54 // Some intrinsic operators have more than one name (e.g. `operator(.eq.)` and
55 // `operator(==)`). GetAllNames() returns them all, including symbolName.
56 std::forward_list<std::string> GetAllNames(
57     const SemanticsContext &, const SourceName &);
58
59 template <typename T>
60 MaybeIntExpr EvaluateIntExpr(SemanticsContext &context, const T &expr) {
61   if (MaybeExpr maybeExpr{
62           Fold(context.foldingContext(), AnalyzeExpr(context, expr))}) {
63     if (auto *intExpr{evaluate::UnwrapExpr<SomeIntExpr>(*maybeExpr)}) {
64       return std::move(*intExpr);
65     }
66   }
67   return std::nullopt;
68 }
69
70 template <typename T>
71 std::optional<std::int64_t> EvaluateInt64(
72     SemanticsContext &context, const T &expr) {
73   return evaluate::ToInt64(EvaluateIntExpr(context, expr));
74 }
75
76 // Analyze a generic-spec and generate a symbol name and GenericKind for it.
77 class GenericSpecInfo {
78 public:
79   GenericSpecInfo(const parser::DefinedOpName &x) { Analyze(x); }
80   GenericSpecInfo(const parser::GenericSpec &x) { Analyze(x); }
81
82   GenericKind kind() const { return kind_; }
83   const SourceName &symbolName() const { return symbolName_.value(); }
84   // Set the GenericKind in this symbol and resolve the corresponding
85   // name if there is one
86   void Resolve(Symbol *) const;
87   friend llvm::raw_ostream &operator<<(
88       llvm::raw_ostream &, const GenericSpecInfo &);
89
90 private:
91   GenericKind kind_;
92   const parser::Name *parseName_{nullptr};
93   std::optional<SourceName> symbolName_;
94
95   void Analyze(const parser::DefinedOpName &);
96   void Analyze(const parser::GenericSpec &);
97 };
98
99 // Analyze a parser::ArraySpec or parser::CoarraySpec
100 ArraySpec AnalyzeArraySpec(SemanticsContext &, const parser::ArraySpec &);
101 ArraySpec AnalyzeArraySpec(
102     SemanticsContext &, const parser::ComponentArraySpec &);
103 ArraySpec AnalyzeCoarraySpec(
104     SemanticsContext &context, const parser::CoarraySpec &);
105
106 // Perform consistency checks on equivalence sets
107 class EquivalenceSets {
108 public:
109   EquivalenceSets(SemanticsContext &context) : context_{context} {}
110   std::vector<EquivalenceSet> &sets() { return sets_; };
111   // Resolve this designator and add to the current equivalence set
112   void AddToSet(const parser::Designator &);
113   // Finish the current equivalence set: determine if it overlaps
114   // with any of the others and perform necessary merges if it does.
115   void FinishSet(const parser::CharBlock &);
116
117 private:
118   bool CheckCanEquivalence(
119       const parser::CharBlock &, const Symbol &, const Symbol &);
120   void MergeInto(const parser::CharBlock &, EquivalenceSet &, std::size_t);
121   const EquivalenceObject *Find(const EquivalenceSet &, const Symbol &);
122   bool CheckDesignator(const parser::Designator &);
123   bool CheckDataRef(const parser::CharBlock &, const parser::DataRef &);
124   bool CheckObject(const parser::Name &);
125   bool CheckArrayBound(const parser::Expr &);
126   bool CheckSubstringBound(const parser::Expr &, bool);
127   bool IsCharacterSequenceType(const DeclTypeSpec *);
128   bool IsDefaultKindNumericType(const IntrinsicTypeSpec &);
129   bool IsNumericSequenceType(const DeclTypeSpec *);
130   bool IsSequenceType(
131       const DeclTypeSpec *, std::function<bool(const IntrinsicTypeSpec &)>);
132
133   SemanticsContext &context_;
134   std::vector<EquivalenceSet> sets_; // all equivalence sets in this scope
135   // Map object to index of set it is in
136   std::map<EquivalenceObject, std::size_t> objectToSet_;
137   EquivalenceSet currSet_; // equivalence set currently being constructed
138   struct {
139     Symbol *symbol{nullptr};
140     std::vector<ConstantSubscript> subscripts;
141     std::optional<ConstantSubscript> substringStart;
142   } currObject_; // equivalence object currently being constructed
143 };
144
145 } // namespace Fortran::semantics
146 #endif // FORTRAN_SEMANTICS_RESOLVE_NAMES_H_