Lines Matching +defs:t +defs:exec
182 // Make a placeholder symbol for a Name that otherwise wouldn't have one.
597 // Note: don't use FindSymbol here. If this is a derived type scope,
1073 // there isn't a type specified it comes from the entity in the containing
1077 // a DATA statement or an array constructor). If there isn't an explict
1240 // Check that construct names don't conflict with other names.
1282 bool Pre(const parser::WhereConstructStmt &x) { return CheckDef(x.t); }
1283 bool Pre(const parser::ForallConstructStmt &x) { return CheckDef(x.t); }
1284 bool Pre(const parser::CriticalStmt &x) { return CheckDef(x.t); }
1288 bool Pre(const parser::NonLabelDoStmt &x) { return CheckDef(x.t); }
1289 bool Pre(const parser::IfThenStmt &x) { return CheckDef(x.t); }
1290 bool Pre(const parser::SelectCaseStmt &x) { return CheckDef(x.t); }
1294 return CheckDef(std::get<0>(x.t));
1297 return CheckDef(std::get<0>(x.t));
1301 void Post(const parser::MaskedElsewhereStmt &x) { CheckRef(x.t); }
1307 void Post(const parser::ElseIfStmt &x) { CheckRef(x.t); }
1310 void Post(const parser::CaseStmt &x) { CheckRef(x.t); }
1312 void Post(const parser::SelectRankCaseStmt &x) { CheckRef(x.t); }
1313 void Post(const parser::TypeGuardStmt &x) { CheckRef(x.t); }
1338 template <typename T> bool CheckDef(const T &t) {
1339 return CheckDef(std::get<std::optional<parser::Name>>(t));
1341 template <typename T> void CheckRef(const T &t) {
1342 CheckRef(std::get<std::optional<parser::Name>>(t));
1395 const auto &beginBlockDir{std::get<parser::AccBeginBlockDirective>(x.t)};
1396 const auto &beginDir{std::get<parser::AccBlockDirective>(beginBlockDir.t)};
1531 const auto &spec{std::get<parser::OmpDeclareTargetSpecifier>(x.t)};
1560 std::get<parser::OmpObjectList>(toClause->v.t));
1622 const auto &beginBlockDir{std::get<parser::OmpBeginBlockDirective>(x.t)};
1623 const auto &beginDir{std::get<parser::OmpBlockDirective>(beginBlockDir.t)};
1665 const auto &spec{std::get<parser::OmpDeclareMapperSpecifier>(x.t)};
1667 if (const auto &mapperName{std::get<std::optional<parser::Name>>(spec.t)}) {
1678 Walk(std::get<parser::TypeSpec>(spec.t));
1679 const auto &varName{std::get<parser::ObjectName>(spec.t)};
1682 Walk(std::get<parser::OmpClauseList>(x.t));
1992 // don't try to override explicit binding name with default
2021 x.t)}) {
2024 isCDefined_ = std::get<bool>(x.t);
2173 // Check that we're expecting to see a DeclTypeSpec (and haven't seen one yet)
2226 auto loLoc{std::get<parser::Location>(x.t)};
2228 if (auto hiLocOpt{std::get<std::optional<parser::Location>>(x.t)}) {
2429 // don't report another error about prev
2568 // Create a dummy symbol so we can't create another one with the same
2854 // Convert symbol to be a ObjectEntity or return false if it can't be.
2880 // Convert symbol to be a ProcEntity or return false if it can't be.
2889 // Don't turn function result into a procedure pointer unless both
3075 AddUseRename(std::get<1>(names->t).source, useStmt.moduleName.source);
3097 const auto &localName{std::get<0>(x.t)};
3098 const auto &useName{std::get<1>(x.t)};
3105 const parser::DefinedOpName &local{std::get<0>(x.t)};
3106 const parser::DefinedOpName &use{std::get<1>(x.t)};
3152 useNames.insert(std::get<1>(names.t).source);
3155 useNames.insert(std::get<1>(ops.t).v.source);
3314 return true; // don't try to merge generics (or whatever)
3724 const auto &ancestorName{std::get<parser::Name>(parentId.t)};
3729 std::get<std::optional<parser::Name>>(parentId.t)}) {
3746 set_inheritFromParent(false); // submodules don't inherit parents' implicits
3849 auto kind{std::get<parser::ProcedureStmt::Kind>(x.t)};
3850 const auto &names{std::get<std::list<parser::Name>>(x.t)};
3865 const auto &names{std::get<std::list<parser::Name>>(x.t)};
4049 const auto &name{std::get<parser::Name>(x.t)};
4084 for (const auto &dummyName : std::get<std::list<parser::Name>>(x.t)) {
4275 std::get<parser::Statement<parser::SubroutineStmt>>(x.t).statement.t};
4281 const auto &stmt{std::get<parser::Statement<parser::SubroutineStmt>>(x.t)};
4283 &std::get<std::optional<parser::LanguageBindingSpec>>(stmt.statement.t));
4287 std::get<parser::Statement<parser::FunctionStmt>>(x.t).statement.t};
4293 const auto &stmt{std::get<parser::Statement<parser::FunctionStmt>>(x.t)};
4295 std::get<std::optional<parser::Suffix>>(stmt.statement.t)};
4301 Walk(std::get<std::list<parser::PrefixSpec>>(stmt.t));
4302 Walk(std::get<parser::Name>(stmt.t));
4303 Walk(std::get<std::list<parser::DummyArg>>(stmt.t));
4304 // Don't traverse the LanguageBindingSpec now; it's deferred to EndSubprogram.
4307 for (const auto &dummyArg : std::get<std::list<parser::DummyArg>>(stmt.t)) {
4328 const auto &name{std::get<parser::Name>(stmt.t)};
4331 for (const auto &dummyName : std::get<std::list<parser::Name>>(stmt.t)) {
4406 if (const auto &suffix{std::get<std::optional<parser::Suffix>>(stmt.t)}) {
4439 const auto &entryName{std::get<parser::Name>(stmt.t)};
4445 const auto &suffix{std::get<std::optional<parser::Suffix>>(stmt.t)};
4448 suffix->binding->t)
4476 // that its name doesn't clash with anything.
4538 for (const auto &dummyArg : std::get<std::list<parser::DummyArg>>(stmt.t)) {
4576 const auto &name{std::get<parser::Name>(stmt.t)};
4606 for (const auto &dummyArg : std::get<std::list<parser::DummyArg>>(stmt.t)) {
4694 // Don't return here because it can be useful to have the scope set for
4757 std::get<std::optional<parser::Suffix>>(entryStmt.t)}) {
4758 const auto &name{std::get<parser::Name>(entryStmt.t)};
4837 bindingSpec->t)
4840 // in a new global scope, so that its symbol's name won't clash
4873 set_inheritFromParent(false); // interfaces don't inherit, even if MODULE
4894 // Don't let unnamed BLOCK DATA conflict with unnamed PROGRAM
4903 // Search for the name but don't resolve it
4908 // symbol doesn't inherit it and ruin the ability to check it.
4981 // Report error if accessibility of symbol doesn't match isPrivate.
4995 for (const auto &attr : std::get<std::list<parser::AttrSpec>>(x.t)) {
4997 for (const auto &decl : std::get<std::list<parser::EntityDecl>>(x.t)) {
5010 DeclareObjectEntity(std::get<parser::Name>(x.t));
5013 DeclareObjectEntity(std::get<parser::Name>(x.t));
5024 const auto &name{std::get<parser::ObjectName>(x.t)};
5030 if (const auto &init{std::get<std::optional<parser::Initialization>>(x.t)}) {
5048 const auto &name{std::get<parser::Name>(x.t)};
5050 std::get<std::optional<parser::DeferredShapeSpecList>>(x.t)}) {
5069 HandleAttributeStmt(Attr::POINTER, std::get<parser::Name>(x.t));
5074 auto kind{std::get<parser::BindEntity::Kind>(x.t)};
5075 auto &name{std::get<parser::Name>(x.t)};
5103 auto &name{std::get<parser::NamedConstant>(x.t).v};
5113 const auto &expr{std::get<parser::ConstantExpr>(x.t)};
5168 const parser::Name &name{std::get<parser::NamedConstant>(enumerator.t).v};
5188 enumerator.t)}) {
5266 auto &intentSpec{std::get<parser::IntentSpec>(x.t)};
5267 auto &names{std::get<std::list<parser::Name>>(x.t)};
5330 auto attr{std::get<common::CUDADataAttr>(x.t)};
5331 for (const auto &name : std::get<std::list<parser::Name>>(x.t)) {
5401 const auto &name{std::get<parser::ObjectName>(x.t)};
5740 const parser::Name &derivedName{std::get<parser::Name>(type.derived.t)};
5753 const auto &typeName{std::get<parser::Name>(parsedClass.derived.t)};
5763 const auto &typeName{std::get<parser::Name>(x.t)};
5770 std::get<std::list<parser::TypeParamSpec>>(x.t)) {
5772 std::get<std::optional<parser::Keyword>>(typeParamSpec.t)};
5781 const auto &value{std::get<parser::TypeParamValue>(typeParamSpec.t)};
5857 auto &stmt{std::get<parser::Statement<parser::DerivedTypeStmt>>(x.t)};
5859 Walk(std::get<std::list<parser::Statement<parser::TypeParamDefStmt>>>(x.t));
5864 for (auto ¶mName : std::get<std::list<parser::Name>>(stmt.statement.t)) {
5874 Walk(std::get<std::list<parser::Statement<parser::PrivateOrSequence>>>(x.t));
5876 std::get<std::list<parser::Statement<parser::ComponentDefStmt>>>(x.t)};
5894 Walk(std::get<std::optional<parser::TypeBoundProcedurePart>>(x.t));
5895 Walk(std::get<parser::Statement<parser::EndTypeStmt>>(x.t));
5906 auto &name{std::get<parser::Name>(x.t)};
5945 for (const auto &name : std::get<std::list<parser::Name>>(x.t)) {
5960 auto attr{std::get<common::TypeParamAttr>(x.t)};
5961 for (auto &decl : std::get<std::list<parser::TypeParamDecl>>(x.t)) {
5962 auto &name{std::get<parser::Name>(decl.t)};
5969 decl.t)}) {
6023 const auto &name{std::get<parser::Name>(x.t)};
6069 if (auto &init{std::get<std::optional<parser::Initialization>>(x.t)}) {
6080 const auto &name{std::get<parser::Name>(x.t)};
6090 const auto &procAttrSpec{std::get<std::list<parser::ProcAttrSpec>>(x.t)};
6094 bindC->t)
6096 if (std::get<std::list<parser::ProcDecl>>(x.t).size() > 1) {
6113 Walk(std::get<std::list<parser::ComponentAttrSpec>>(x.t));
6116 Walk(std::get<parser::DeclarationTypeSpec>(x.t));
6132 Walk(std::get<std::list<parser::ComponentOrFill>>(x.t));
6164 const auto &name{std::get<parser::Name>(x.t)};
6165 // Don't use BypassGeneric or GetUltimate on this symbol, they can
6236 auto &bindingName{std::get<parser::Name>(declaration.t)};
6237 auto &optName{std::get<std::optional<parser::Name>>(declaration.t)};
6259 auto &bindingName{std::get<parser::Name>(declaration.t)};
6333 const auto &accessSpec{std::get<std::optional<parser::AccessSpec>>(x.t)};
6334 const auto &genericSpec{std::get<Indirection<parser::GenericSpec>>(x.t)};
6335 const auto &bindingNames{std::get<std::list<parser::Name>>(x.t)};
6381 std::get<parser::Statement<parser::StructureStmt>>(def.t)};
6392 const auto &name{std::get<std::optional<parser::Name>>(structStmt.t)};
6405 const auto &fields{std::get<std::list<parser::StructureField>>(def.t)};
6422 const auto &decls{std::get<std::list<parser::EntityDecl>>(structStmt.t)};
6461 auto &parsedType{std::get<parser::DerivedTypeSpec>(x.t)};
6478 std::get<std::list<parser::ComponentSpec>>(x.t)) {
6481 Walk(std::get<parser::ComponentDataSource>(component.t));
6482 if (const auto &kw{std::get<std::optional<parser::Keyword>>(component.t)}) {
6495 const parser::ObjectName &pointerName{std::get<0>(bp.t)};
6521 const parser::ObjectName &pointeeName{std::get<1>(bp.t)};
6558 const auto &groupName{std::get<parser::Name>(x.t)};
6573 if (auto *groupSymbol{FindInScope(std::get<parser::Name>(group->t))}) {
6575 for (const auto &name : std::get<std::list<parser::Name>>(group->t)) {
6618 const auto &name{std::get<parser::Name>(x.t)};
6635 return false; // don't implicitly declare names yet
6672 auto kind{std::get<parser::SavedEntity::Kind>(y.t)};
6673 const auto &name{std::get<parser::Name>(y.t)};
6973 // the name can't be repurposed there later as something else.
7013 // Subtlety: Don't let a "*length" specifier (if any is pending) affect the
7203 if (context().HasError(*prev)) { // don't pile on
7266 const parser::Name &name{std::get<parser::Name>(control.t)};
7322 Walk(std::get<std::optional<parser::IntegerTypeSpec>>(header.t));
7324 std::get<std::list<parser::ConcurrentControl>>(header.t)};
7329 Walk(std::get<std::optional<parser::ScalarLogicalExpr>>(header.t));
7349 for (const auto &name : std::get<std::list<parser::Name>>(x.t)) {
7379 auto &values{std::get<std::list<parser::AcValue>>(x.t)};
7380 auto &control{std::get<parser::AcImpliedDoControl>(x.t)};
7381 auto &type{std::get<std::optional<parser::IntegerTypeSpec>>(control.t)};
7382 auto &bounds{std::get<parser::AcImpliedDoControl::Bounds>(control.t)};
7401 auto &objects{std::get<std::list<parser::DataIDoObject>>(x.t)};
7402 auto &type{std::get<std::optional<parser::IntegerTypeSpec>>(x.t)};
7403 auto &bounds{std::get<parser::DataImpliedDo::Bounds>(x.t)};
7469 const auto &data{std::get<parser::DataStmtConstant>(x.t)};
7510 const auto &[blockStmt, specPart, execPart, endBlockStmt] = x.t;
7528 CheckDef(x.t);
7530 const auto assocCount{std::get<std::list<parser::Association>>(x.t).size()};
7555 const auto &name{std::get<parser::Name>(x.t)};
7561 CheckDef(x.t);
7568 const auto &decl{std::get<parser::CodimensionDecl>(x.t)};
7569 const auto &name{std::get<parser::Name>(decl.t)};
7571 const auto &selector{std::get<parser::Selector>(x.t)};
7589 CheckRef(x.t);
7603 if (const std::optional<parser::Name> &name{std::get<1>(x.t)}) {
7604 // This isn't a name in the current scope, it is in each TypeGuardStmt
7644 if (const std::optional<parser::Name> &name{std::get<1>(x.t)}) {
7645 // This isn't a name in the current scope, it is in each SelectRankCaseStmt
7669 // CLASS IS (t)
7690 // Don't call SetAttrsFromAssociation() for SELECT RANK.
7912 Hide(std::get<parser::Name>(x.t));
7925 // Don't have to worry about INTENT(), VALUE, or OPTIONAL
7929 Hide(std::get<parser::ObjectName>(x.t));
7933 Hide(std::get<parser::ObjectName>(x.t));
7937 Hide(std::get<parser::Name>(x.t));
7941 Hide(std::get<parser::Name>(x.t));
7951 Hide(std::get<parser::Name>(x.t));
7968 Hide(std::get<parser::Name>(decl.t));
7993 Hide(std::get<0>(names->t));
8003 Hide(std::get<parser::Name>(x.t));
8014 if (const auto &maybeName{std::get<1>(x.t)}) {
8025 if (const auto &maybeName{std::get<1>(x.t)}) {
8254 Walk(std::get<parser::SubstringRange>(x.t).t);
8255 return ResolveDataRef(std::get<parser::DataRef>(x.t));
8292 // Otherwise, report an error if it hasn't been declared.
8357 // execution parts, this may be the first time we see the symbol. It can't be a
8603 // something like "REAL, EXTERNAL, POINTER :: p => t"
8699 std::get<parser::ProcedureDesignator>(call.t).u);
8700 const auto &arguments{std::get<std::list<parser::ActualArgSpec>>(call.t)};
8708 const auto &actual{std::get<parser::ActualArg>(argSpec.t)};
8756 // use of this name as a local symbol; but don't actually use this new
8887 symbol.set(flag); // in case it hasn't been set yet
8905 Attr accessAttr{AccessSpecToAttr(std::get<parser::AccessSpec>(x.t))};
8912 const auto &accessIds{std::get<std::list<parser::AccessId>>(x.t)};
8988 std::get<parser::DeclarationTypeSpec>(spec.t)};
9002 std::get<parser::Name>(dtSpec->t).source);
9017 dtDef->value().t)
9019 const parser::Name &name{std::get<parser::Name>(dtStmt.t)};
9036 implicitPart, decls] = x.t;
9083 CreateGeneric(std::get<parser::GenericSpec>(y.statement.value().t));
9087 y.value().t)};
9113 const auto &[name, objects] = block.t;
9116 Symbol &obj{DeclareObjectEntity(std::get<parser::Name>(object.t))};
9129 std::get<parser::ObjectName>(decl.t), Attrs{}),
9261 const auto &name{std::get<parser::Name>(stmtFunc.t)};
9272 const auto &parsedExpr{std::get<parser::Scalar<parser::Expr>>(stmtFunc.t)};
9355 const auto &dataRef{std::get<parser::DataRef>(x.t)};
9356 const auto &bounds{std::get<parser::PointerAssignmentStmt::Bounds>(x.t)};
9357 const auto &expr{std::get<parser::Expr>(x.t)};
9408 Walk(std::get<parser::SubstringRange>(x.v.t).t);
9409 ResolveDataRef(std::get<parser::DataRef>(x.v.t));
9425 const auto &names{std::get<std::list<parser::Name>>(x.t)};
9448 if (auto *name{ResolveName(std::get<parser::Name>(x.t))}) {
9454 if (auto *name{ResolveName(std::get<parser::Name>(x.t))}) {
9489 std::get<std::optional<std::list<const char *>>>(item.t)}) {
9493 case 't':
9531 const auto &name{std::get<parser::Name>(item.t)};
9581 const auto &spec{std::get<parser::SpecificationPart>(x.t)};
9584 spec.t)};
9607 std::get<parser::Statement<parser::ModuleStmt>>(mod.t)};
9684 // to be procedures, so that they don't get converted to objects by default.
9690 void Walk(const parser::ExecutionPart &exec) {
9691 parser::Walk(exec, *this);
9708 auto &designator{std::get<parser::ProcedureDesignator>(call.t)};
9771 if (node.exec()) {
9772 ExecutionPartCallSkimmer{*this}.Walk(*node.exec());
9773 HandleImpliedAsynchronousInScope(node.exec()->v);
9825 MakeSymbol(std::get<parser::Name>(entryStmt->t), std::move(details))};
9884 stmt->statement.t)}) {
9893 stmt->statement.t);
9919 const auto &name{std::get<parser::Name>(x.t)};
9943 Init(std::get<parser::Name>(decl.t),
9944 std::get<std::optional<parser::Initialization>>(decl.t));
9948 Init(std::get<parser::Name>(decl.t),
9949 std::get<std::optional<parser::Initialization>>(decl.t));
9954 std::get<std::optional<parser::ProcPointerInit>>(decl.t)}) {
9955 resolver_.PointerInitialization(std::get<parser::Name>(decl.t), *init);
10031 if (node.exec()) {
10032 DeferredCheckVisitor{*this}.Walk(*node.exec());
10077 if (const auto *exec{node.exec()}) {
10078 Walk(*exec);