FLANG

tools.h
1 //===-- include/flang/Semantics/tools.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_TOOLS_H_
10 #define FORTRAN_SEMANTICS_TOOLS_H_
11
12 // Simple predicates and look-up functions that are best defined
13 // canonically for use in semantic checking.
14
15 #include "flang/Common/Fortran.h"
16 #include "flang/Evaluate/expression.h"
17 #include "flang/Evaluate/type.h"
18 #include "flang/Evaluate/variable.h"
19 #include "flang/Parser/message.h"
20 #include "flang/Parser/parse-tree.h"
21 #include "flang/Semantics/attr.h"
22 #include "flang/Semantics/expression.h"
23 #include "flang/Semantics/semantics.h"
24 #include <functional>
25
26 namespace Fortran::semantics {
27
28 class DeclTypeSpec;
29 class DerivedTypeSpec;
30 class Scope;
31 class Symbol;
32
33 const Scope *FindModuleContaining(const Scope &);
34 const Scope *FindProgramUnitContaining(const Scope &);
35 const Scope *FindProgramUnitContaining(const Symbol &);
36 const Scope *FindPureProcedureContaining(const Scope &);
37 const Scope *FindPureProcedureContaining(const Symbol &);
38 const Symbol *FindPointerComponent(const Scope &);
39 const Symbol *FindPointerComponent(const DerivedTypeSpec &);
40 const Symbol *FindPointerComponent(const DeclTypeSpec &);
41 const Symbol *FindPointerComponent(const Symbol &);
42 const Symbol *FindInterface(const Symbol &);
43 const Symbol *FindSubprogram(const Symbol &);
44 const Symbol *FindFunctionResult(const Symbol &);
45 const Symbol *FindOverriddenBinding(const Symbol &);
46
47 const DeclTypeSpec *FindParentTypeSpec(const DerivedTypeSpec &);
48 const DeclTypeSpec *FindParentTypeSpec(const DeclTypeSpec &);
49 const DeclTypeSpec *FindParentTypeSpec(const Scope &);
50 const DeclTypeSpec *FindParentTypeSpec(const Symbol &);
51
52 enum class Tristate { No, Yes, Maybe };
53 inline Tristate ToTristate(bool x) { return x ? Tristate::Yes : Tristate::No; }
54
55 // Is this a user-defined assignment? If both sides are the same derived type
56 // (and the ranks are okay) the answer is Maybe.
57 Tristate IsDefinedAssignment(
58 const std::optional<evaluate::DynamicType> &lhsType, int lhsRank,
59 const std::optional<evaluate::DynamicType> &rhsType, int rhsRank);
60 // Test for intrinsic unary and binary operators based on types and ranks
61 bool IsIntrinsicRelational(common::RelationalOperator,
62 const evaluate::DynamicType &, int, const evaluate::DynamicType &, int);
63 bool IsIntrinsicNumeric(const evaluate::DynamicType &);
64 bool IsIntrinsicNumeric(
65 const evaluate::DynamicType &, int, const evaluate::DynamicType &, int);
66 bool IsIntrinsicLogical(const evaluate::DynamicType &);
67 bool IsIntrinsicLogical(
68 const evaluate::DynamicType &, int, const evaluate::DynamicType &, int);
69 bool IsIntrinsicConcat(
70 const evaluate::DynamicType &, int, const evaluate::DynamicType &, int);
71
72 bool IsGenericDefinedOp(const Symbol &);
73 bool DoesScopeContain(const Scope *maybeAncestor, const Scope &maybeDescendent);
74 bool DoesScopeContain(const Scope *, const Symbol &);
75 bool IsUseAssociated(const Symbol &, const Scope &);
76 bool IsHostAssociated(const Symbol &, const Scope &);
77 inline bool IsStmtFunction(const Symbol &symbol) {
78 const auto *subprogram{symbol.detailsIf<SubprogramDetails>()};
79 return subprogram && subprogram->stmtFunction();
80 }
81 bool IsInStmtFunction(const Symbol &);
82 bool IsStmtFunctionDummy(const Symbol &);
83 bool IsStmtFunctionResult(const Symbol &);
84 bool IsPointerDummy(const Symbol &);
85 bool IsBindCProcedure(const Symbol &);
86 bool IsBindCProcedure(const Scope &);
87 bool IsProcName(const Symbol &); // proc-name
88 bool IsFunctionResultWithSameNameAsFunction(const Symbol &);
89 bool IsExtensibleType(const DerivedTypeSpec *);
90 bool IsBuiltinDerivedType(const DerivedTypeSpec *derived, const char *name);
91 // Is this derived type TEAM_TYPE from module ISO_FORTRAN_ENV
92 bool IsTeamType(const DerivedTypeSpec *);
93 // Is this derived type either C_PTR or C_FUNPTR from module ISO_C_BINDING
94 bool IsIsoCType(const DerivedTypeSpec *);
95 bool IsEventTypeOrLockType(const DerivedTypeSpec *);
96 bool IsOrContainsEventOrLockComponent(const Symbol &);
97 bool CanBeTypeBoundProc(const Symbol *);
98 bool IsInitialized(const Symbol &, bool ignoreDATAstatements = false);
99 bool HasIntrinsicTypeName(const Symbol &);
100 bool IsSeparateModuleProcedureInterface(const Symbol *);
101 bool IsAutomatic(const Symbol &);
102 bool HasAlternateReturns(const Symbol &);
103
104 // Return an ultimate component of type that matches predicate, or nullptr.
105 const Symbol *FindUltimateComponent(const DerivedTypeSpec &type,
106 const std::function<bool(const Symbol &)> &predicate);
107 const Symbol *FindUltimateComponent(
108 const Symbol &symbol, const std::function<bool(const Symbol &)> &predicate);
109
110 // Returns an immediate component of type that matches predicate, or nullptr.
111 // An immediate component of a type is one declared for that type or is an
112 // immediate component of the type that it extends.
113 const Symbol *FindImmediateComponent(
114 const DerivedTypeSpec &, const std::function<bool(const Symbol &)> &);
115
116 inline bool IsPointer(const Symbol &symbol) {
117 return symbol.attrs().test(Attr::POINTER);
118 }
119 inline bool IsAllocatable(const Symbol &symbol) {
120 return symbol.attrs().test(Attr::ALLOCATABLE);
121 }
122 inline bool IsAllocatableOrPointer(const Symbol &symbol) {
123 return IsPointer(symbol) || IsAllocatable(symbol);
124 }
125 inline bool IsNamedConstant(const Symbol &symbol) {
126 return symbol.attrs().test(Attr::PARAMETER);
127 }
128 inline bool IsOptional(const Symbol &symbol) {
129 return symbol.attrs().test(Attr::OPTIONAL);
130 }
131 inline bool IsIntentIn(const Symbol &symbol) {
132 return symbol.attrs().test(Attr::INTENT_IN);
133 }
134 inline bool IsIntentInOut(const Symbol &symbol) {
135 return symbol.attrs().test(Attr::INTENT_INOUT);
136 }
137 inline bool IsIntentOut(const Symbol &symbol) {
138 return symbol.attrs().test(Attr::INTENT_OUT);
139 }
140 inline bool IsProtected(const Symbol &symbol) {
141 return symbol.attrs().test(Attr::PROTECTED);
142 }
143 inline bool IsImpliedDoIndex(const Symbol &symbol) {
144 return symbol.owner().kind() == Scope::Kind::ImpliedDos;
145 }
146 bool IsFinalizable(const Symbol &);
147 bool IsFinalizable(const DerivedTypeSpec &);
148 bool HasImpureFinal(const DerivedTypeSpec &);
149 bool IsCoarray(const Symbol &);
150 bool IsInBlankCommon(const Symbol &);
151 bool IsAutomaticObject(const Symbol &);
152 inline bool IsAssumedSizeArray(const Symbol &symbol) {
153 const auto *details{symbol.detailsIf<ObjectEntityDetails>()};
154 return details && details->IsAssumedSize();
155 }
156 inline bool IsAssumedRankArray(const Symbol &symbol) {
157 const auto *details{symbol.detailsIf<ObjectEntityDetails>()};
158 return details && details->IsAssumedRank();
159 }
160 bool IsAssumedLengthCharacter(const Symbol &);
161 bool IsExternal(const Symbol &);
162 // Is the symbol modifiable in this scope
163 std::optional<parser::MessageFixedText> WhyNotModifiable(
164 const Symbol &, const Scope &);
165 std::optional<parser::Message> WhyNotModifiable(SourceName, const SomeExpr &,
166 const Scope &, bool vectorSubscriptIsOk = false);
167 const Symbol *IsExternalInPureContext(const Symbol &, const Scope &);
168 bool HasCoarray(const parser::Expr &);
169 bool IsPolymorphicAllocatable(const Symbol &);
170 // Return an error if component symbol is not accessible from scope (7.5.4.8(2))
171 std::optional<parser::MessageFormattedText> CheckAccessibleComponent(
172 const semantics::Scope &, const Symbol &);
173
174 // Analysis of image control statements
175 bool IsImageControlStmt(const parser::ExecutableConstruct &);
176 // Get the location of the image control statement in this ExecutableConstruct
177 parser::CharBlock GetImageControlStmtLocation(
178 const parser::ExecutableConstruct &);
179 // Image control statements that reference coarrays need an extra message
180 // to clarify why they're image control statements. This function returns
181 // std::nullopt for ExecutableConstructs that do not require an extra message.
182 std::optional<parser::MessageFixedText> GetImageControlStmtCoarrayMsg(
183 const parser::ExecutableConstruct &);
184
185 // Returns the complete list of derived type parameter symbols in
186 // the order in which their declarations appear in the derived type
187 // definitions (parents first).
188 SymbolVector OrderParameterDeclarations(const Symbol &);
189 // Returns the complete list of derived type parameter names in the
190 // order defined by 7.5.3.2.
191 std::list<SourceName> OrderParameterNames(const Symbol &);
192
193 // Return an existing or new derived type instance
194 const DeclTypeSpec &FindOrInstantiateDerivedType(Scope &, DerivedTypeSpec &&,
195 SemanticsContext &, DeclTypeSpec::Category = DeclTypeSpec::TypeDerived);
196
197 // When a subprogram defined in a submodule defines a separate module
198 // procedure whose interface is defined in an ancestor (sub)module,
199 // returns a pointer to that interface, else null.
200 const Symbol *FindSeparateModuleSubprogramInterface(const Symbol *);
201
202 // Determines whether an object might be visible outside a
203 // pure function (C1594); returns a non-null Symbol pointer for
204 // diagnostic purposes if so.
205 const Symbol *FindExternallyVisibleObject(const Symbol &, const Scope &);
206
207 template <typename A>
208 const Symbol *FindExternallyVisibleObject(const A &, const Scope &) {
209 return nullptr; // default base case
210 }
211
212 template <typename T>
213 const Symbol *FindExternallyVisibleObject(
214 const evaluate::Designator<T> &designator, const Scope &scope) {
215 if (const Symbol * symbol{designator.GetBaseObject().symbol()}) {
216 return FindExternallyVisibleObject(*symbol, scope);
217 } else if (std::holds_alternative<evaluate::CoarrayRef>(designator.u)) {
218 // Coindexed values are visible even if their image-local objects are not.
219 return designator.GetBaseObject().symbol();
220 } else {
221 return nullptr;
222 }
223 }
224
225 template <typename T>
226 const Symbol *FindExternallyVisibleObject(
227 const evaluate::Expr<T> &expr, const Scope &scope) {
228 return std::visit(
229 [&](const auto &x) { return FindExternallyVisibleObject(x, scope); },
230 expr.u);
231 }
232
233 using SomeExpr = evaluate::Expr<evaluate::SomeType>;
234
235 bool ExprHasTypeCategory(
236 const SomeExpr &expr, const common::TypeCategory &type);
237 bool ExprTypeKindIsDefault(
238 const SomeExpr &expr, const SemanticsContext &context);
239
240 struct GetExprHelper {
241 static const SomeExpr *Get(const parser::Expr &);
242 static const SomeExpr *Get(const parser::Variable &);
243 static const SomeExpr *Get(const parser::DataStmtConstant &);
244 template <typename T>
245 static const SomeExpr *Get(const common::Indirection<T> &x) {
246 return Get(x.value());
247 }
248 template <typename T> static const SomeExpr *Get(const std::optional<T> &x) {
249 return x ? Get(*x) : nullptr;
250 }
251 template <typename T> static const SomeExpr *Get(const T &x) {
252 if constexpr (ConstraintTrait<T>) {
253 return Get(x.thing);
254 } else if constexpr (WrapperTrait<T>) {
255 return Get(x.v);
256 } else {
257 return nullptr;
258 }
259 }
260 };
261
262 template <typename T> const SomeExpr *GetExpr(const T &x) {
263 return GetExprHelper{}.Get(x);
264 }
265
266 const evaluate::Assignment *GetAssignment(const parser::AssignmentStmt &);
267 const evaluate::Assignment *GetAssignment(
268 const parser::PointerAssignmentStmt &);
269
270 template <typename T> std::optional<std::int64_t> GetIntValue(const T &x) {
271 if (const auto *expr{GetExpr(x)}) {
272 return evaluate::ToInt64(*expr);
273 } else {
274 return std::nullopt;
275 }
276 }
277
278 template <typename T> bool IsZero(const T &expr) {
279 auto value{GetIntValue(expr)};
280 return value && *value == 0;
281 }
282
283 // Derived type component iterator that provides a C++ LegacyForwardIterator
284 // iterator over the Ordered, Direct, Ultimate or Potential components of a
285 // DerivedTypeSpec. These iterators can be used with STL algorithms
286 // accepting LegacyForwardIterator.
287 // The kind of component is a template argument of the iterator factory
288 // ComponentIterator.
289 //
290 // - Ordered components are the components from the component order defined
291 // in 7.5.4.7, except that the parent component IS added between the parent
292 // component order and the components in order of declaration.
293 // This "deviation" is important for structure-constructor analysis.
294 // For this kind of iterator, the component tree is recursively visited in the
295 // following order:
296 // - first, the Ordered components of the parent type (if relevant)
297 // - then, the parent component (if relevant, different from 7.5.4.7!)
298 // - then, the components in declaration order (without visiting subcomponents)
299 //
300 // - Ultimate, Direct and Potential components are as defined in 7.5.1.
301 // - Ultimate components of a derived type are the closure of its components
302 // of intrinsic type, its ALLOCATABLE or POINTER components, and the
303 // ultimate components of its non-ALLOCATABLE non-POINTER derived type
304 // components. (No ultimate component has a derived type unless it is
305 // ALLOCATABLE or POINTER.)
306 // - Direct components of a derived type are all of its components, and all
307 // of the direct components of its non-ALLOCATABLE non-POINTER derived type
308 // components. (Direct components are always present.)
309 // - Potential subobject components of a derived type are the closure of
310 // its non-POINTER components and the potential subobject components of
311 // its non-POINTER derived type components. (The lifetime of each
312 // potential subobject component is that of the entire instance.)
313 // Parent and procedure components are considered against these definitions.
314 // For this kind of iterator, the component tree is recursively visited in the
315 // following order:
316 // - the parent component first (if relevant)
317 // - then, the components of the parent type (if relevant)
318 // + visiting the component and then, if it is derived type data component,
319 // visiting the subcomponents before visiting the next
320 // component in declaration order.
321 // - then, components in declaration order, similarly to components of parent
322 // type.
323 // Here, the parent component is visited first so that search for a component
324 // verifying a property will never descend into a component that already
325 // verifies the property (this helps giving clearer feedback).
326 //
327 // ComponentIterator::const_iterator remain valid during the whole lifetime of
328 // the DerivedTypeSpec passed by reference to the ComponentIterator factory.
329 // Their validity is independent of the ComponentIterator factory lifetime.
330 //
331 // For safety and simplicity, the iterators are read only and can only be
332 // incremented. This could be changed if desired.
333 //
334 // Note that iterators are made in such a way that one can easily test and build
335 // info message in the following way:
336 // ComponentIterator<ComponentKind::...> comp{derived}
337 // if (auto it{std::find_if(comp.begin(), comp.end(), predicate)}) {
338 // msg = it.BuildResultDesignatorName() + " verifies predicates";
339 // const Symbol *component{*it};
340 // ....
341 // }
342
343 ENUM_CLASS(ComponentKind, Ordered, Direct, Ultimate, Potential, Scope)
344
345 template <ComponentKind componentKind> class ComponentIterator {
346 public:
347 ComponentIterator(const DerivedTypeSpec &derived) : derived_{derived} {}
348 class const_iterator {
349 public:
350 using iterator_category = std::forward_iterator_tag;
351 using value_type = SymbolRef;
352 using difference_type = void;
353 using pointer = const Symbol *;
354 using reference = const Symbol &;
355
356 static const_iterator Create(const DerivedTypeSpec &);
357
358 const_iterator &operator++() {
359 Increment();
360 return *this;
361 }
362 const_iterator operator++(int) {
363 const_iterator tmp(*this);
364 Increment();
365 return tmp;
366 }
367 reference operator*() const {
368 CHECK(!componentPath_.empty());
369 return DEREF(componentPath_.back().component());
370 }
371 pointer operator->() const { return &**this; }
372
373 bool operator==(const const_iterator &other) const {
374 return componentPath_ == other.componentPath_;
375 }
376 bool operator!=(const const_iterator &other) const {
377 return !(*this == other);
378 }
379
380 // bool() operator indicates if the iterator can be dereferenced without
381 // having to check against an end() iterator.
382 explicit operator bool() const { return !componentPath_.empty(); }
383
384 // Builds a designator name of the referenced component for messages.
385 // The designator helps when the component referred to by the iterator
386 // may be "buried" into other components. This gives the full
387 // path inside the iterated derived type: e.g "%a%b%c%ultimate"
388 // when it->name() only gives "ultimate". Parent components are
389 // part of the path for clarity, even though they could be
390 // skipped.
391 std::string BuildResultDesignatorName() const;
392
393 private:
394 using name_iterator =
395 std::conditional_t<componentKind == ComponentKind::Scope,
396 typename Scope::const_iterator,
397 typename std::list<SourceName>::const_iterator>;
398
399 class ComponentPathNode {
400 public:
401 explicit ComponentPathNode(const DerivedTypeSpec &derived)
402 : derived_{derived} {
403 if constexpr (componentKind == ComponentKind::Scope) {
404 const Scope &scope{DEREF(derived.scope())};
405 nameIterator_ = scope.cbegin();
406 nameEnd_ = scope.cend();
407 } else {
408 const std::list<SourceName> &nameList{
409 derived.typeSymbol().get<DerivedTypeDetails>().componentNames()};
410 nameIterator_ = nameList.cbegin();
411 nameEnd_ = nameList.cend();
412 }
413 }
414 const Symbol *component() const { return component_; }
415 void set_component(const Symbol &component) { component_ = &component; }
416 bool visited() const { return visited_; }
417 void set_visited(bool yes) { visited_ = yes; }
418 bool descended() const { return descended_; }
419 void set_descended(bool yes) { descended_ = yes; }
420 name_iterator &nameIterator() { return nameIterator_; }
421 name_iterator nameEnd() { return nameEnd_; }
422 const Symbol &GetTypeSymbol() const { return derived_->typeSymbol(); }
423 const Scope &GetScope() const { return DEREF(derived_->scope()); }
424 bool operator==(const ComponentPathNode &that) const {
425 return &*derived_ == &*that.derived_ &&
426 nameIterator_ == that.nameIterator_ &&
427 component_ == that.component_;
428 }
429
430 private:
431 common::Reference<const DerivedTypeSpec> derived_;
432 name_iterator nameEnd_;
433 name_iterator nameIterator_;
434 const Symbol *component_{nullptr}; // until Increment()
435 bool visited_{false};
436 bool descended_{false};
437 };
438
439 const DerivedTypeSpec *PlanComponentTraversal(
440 const Symbol &component) const;
441 // Advances to the next relevant symbol, if any. Afterwards, the
442 // iterator will either be at its end or contain no null component().
443 void Increment();
444
445 std::vector<ComponentPathNode> componentPath_;
446 };
447
448 const_iterator begin() { return cbegin(); }
449 const_iterator end() { return cend(); }
450 const_iterator cbegin() { return const_iterator::Create(derived_); }
451 const_iterator cend() { return const_iterator{}; }
452
453 private:
454 const DerivedTypeSpec &derived_;
455 };
456
457 extern template class ComponentIterator<ComponentKind::Ordered>;
458 extern template class ComponentIterator<ComponentKind::Direct>;
459 extern template class ComponentIterator<ComponentKind::Ultimate>;
460 extern template class ComponentIterator<ComponentKind::Potential>;
461 extern template class ComponentIterator<ComponentKind::Scope>;
462 using OrderedComponentIterator = ComponentIterator<ComponentKind::Ordered>;
463 using DirectComponentIterator = ComponentIterator<ComponentKind::Direct>;
464 using UltimateComponentIterator = ComponentIterator<ComponentKind::Ultimate>;
465 using PotentialComponentIterator = ComponentIterator<ComponentKind::Potential>;
466 using ScopeComponentIterator = ComponentIterator<ComponentKind::Scope>;
467
468 // Common component searches, the iterator returned is referring to the first
469 // component, according to the order defined for the related ComponentIterator,
470 // that verifies the property from the name.
471 // If no component verifies the property, an end iterator (casting to false)
472 // is returned. Otherwise, the returned iterator casts to true and can be
473 // dereferenced.
474 PotentialComponentIterator::const_iterator FindEventOrLockPotentialComponent(
475 const DerivedTypeSpec &);
476 UltimateComponentIterator::const_iterator FindCoarrayUltimateComponent(
477 const DerivedTypeSpec &);
478 UltimateComponentIterator::const_iterator FindPointerUltimateComponent(
479 const DerivedTypeSpec &);
480 UltimateComponentIterator::const_iterator FindAllocatableUltimateComponent(
481 const DerivedTypeSpec &);
482 UltimateComponentIterator::const_iterator
483 FindPolymorphicAllocatableUltimateComponent(const DerivedTypeSpec &);
484 UltimateComponentIterator::const_iterator
485 FindPolymorphicAllocatableNonCoarrayUltimateComponent(const DerivedTypeSpec &);
486
487 // The LabelEnforce class (given a set of labels) provides an error message if
488 // there is a branch to a label which is not in the given set.
489 class LabelEnforce {
490 public:
491 LabelEnforce(SemanticsContext &context, std::set<parser::Label> &&labels,
492 parser::CharBlock constructSourcePosition, const char *construct)
493 : context_{context}, labels_{labels},
494 constructSourcePosition_{constructSourcePosition}, construct_{
495 construct} {}
496 template <typename T> bool Pre(const T &) { return true; }
497 template <typename T> bool Pre(const parser::Statement<T> &statement) {
498 currentStatementSourcePosition_ = statement.source;
499 return true;
500 }
501
502 template <typename T> void Post(const T &) {}
503
504 void Post(const parser::GotoStmt &gotoStmt);
505 void Post(const parser::ComputedGotoStmt &computedGotoStmt);
506 void Post(const parser::ArithmeticIfStmt &arithmeticIfStmt);
507 void Post(const parser::AssignStmt &assignStmt);
508 void Post(const parser::AssignedGotoStmt &assignedGotoStmt);
509 void Post(const parser::AltReturnSpec &altReturnSpec);
510 void Post(const parser::ErrLabel &errLabel);
511 void Post(const parser::EndLabel &endLabel);
512 void Post(const parser::EorLabel &eorLabel);
513 void checkLabelUse(const parser::Label &labelUsed);
514
515 private:
516 SemanticsContext &context_;
517 std::set<parser::Label> labels_;
518 parser::CharBlock currentStatementSourcePosition_{nullptr};
519 parser::CharBlock constructSourcePosition_{nullptr};
520 const char *construct_{nullptr};
521
522 parser::MessageFormattedText GetEnclosingConstructMsg();
523 void SayWithConstruct(SemanticsContext &context,
524 parser::CharBlock stmtLocation, parser::MessageFormattedText &&message,
525 parser::CharBlock constructLocation);
526 };
527
528 } // namespace Fortran::semantics
529 #endif // FORTRAN_SEMANTICS_TOOLS_H_
Fortran::parser::Statement
Definition: parse-tree.h:344
Fortran::semantics::ComponentIterator::const_iterator
Definition: tools.h:348
Fortran::semantics::SemanticsContext
Definition: semantics.h:60
Fortran::parser::MessageFormattedText
Definition: message.h:67
Fortran::semantics::Symbol
Definition: symbol.h:479
Fortran::semantics::DerivedTypeSpec
Definition: type.h:237
Fortran::semantics::DerivedTypeDetails
Definition: symbol.h:249
Fortran::parser::AssignStmt
Definition: parse-tree.h:3274
Fortran::parser::Variable
Definition: parse-tree.h:1780
Fortran::parser::AssignedGotoStmt
Definition: parse-tree.h:3279
Fortran::parser::ComputedGotoStmt
Definition: parse-tree.h:2414
Fortran::common::Reference< const Symbol >
Fortran::common::Indirection
Definition: indirection.h:31
Fortran::parser::DataStmtConstant
Definition: parse-tree.h:1411
Fortran::parser::ArithmeticIfStmt
Definition: parse-tree.h:3269
Fortran::parser::CharBlock
Definition: char-block.h:28
Fortran::semantics::ComponentIterator
Definition: tools.h:345
Fortran::semantics::Scope
Definition: scope.h:56
Fortran::parser::Expr
Definition: parse-tree.h:1624
Fortran::semantics::LabelEnforce
Definition: tools.h:489
Fortran::evaluate::Expr
Definition: common.h:207
Fortran::semantics::GetExprHelper
Definition: tools.h:240