maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/flang/lib/Semantics/check-call.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

906 lines
37 KiB
C++
Raw Normal View History

[flang] [LLVMify F18] Compiler module folders should have capitalised names (flang-compiler/f18#980) This patch renames the modules in f18 to use a capital letter in the module name Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@d2eb7a1c443d1539ef12b6f027074a0eb15b1ea0 Reviewed-on: https://github.com/flang-compiler/f18/pull/980
2020-02-25 23:11:52 +08:00
//===-- lib/Semantics/check-call.cpp --------------------------------------===//
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
//
[flang] Flang relicensing changes for LLVM Apache 2.0 license This changes the license information in many of the flang source files. - Renamed LICENSE to LICENSE.txt. - NVIDIA Copyright lines have been removed. - Initial lines for files follow the LLVM coding convention (file name on the first line; Emacs mode information on the first line). - License references have been replaced with the abridged LLVM text. - License information was removed from the test files. - No file header was placed on test files (these weren't in most LLVM test files). - License information was added to documentation files where it was missing. We did not add brief file summaries to the initial line. See http://llvm.org/docs/DeveloperPolicy.html#new-llvm-project-license-framework for a description of the new license. See http://llvm.org/docs/CodingStandards.html#file-headers for a description of the new LLVM standard file header. Original-commit: flang-compiler/f18@add6cde7244b926ca457a1c74c21fea071b85329 Reviewed-on: https://github.com/flang-compiler/f18/pull/887
2019-12-21 04:52:07 +08:00
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
//
[flang] Minor format change to LLVM license lines Replace comment lines containing all dashes with the proper ===-----....----=== markers. Original-commit: flang-compiler/f18@a8936b0d4187a9a9ef43f9d34055a3213beeb9d2 Reviewed-on: https://github.com/flang-compiler/f18/pull/922
2020-01-11 04:12:03 +08:00
//===----------------------------------------------------------------------===//
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
#include "check-call.h"
[flang] Move pointer assignment checking to its own file Create `pointer-assignment.{h,cc}` for pointer assignment checking. It doesn't share with assignment checking so it should be its own file. Move the code into semantics namespace. Original-commit: flang-compiler/f18@1658aba81f24fe3913298e76ae8b9c938bd4d248 Reviewed-on: https://github.com/flang-compiler/f18/pull/928 Tree-same-pre-rewrite: false
2020-01-07 01:16:18 +08:00
#include "pointer-assignment.h"
[flang] [LLVMify F18] Compiler module folders should have capitalised names (flang-compiler/f18#980) This patch renames the modules in f18 to use a capital letter in the module name Signed-off-by: Caroline Concatto <caroline.concatto@arm.com> Original-commit: flang-compiler/f18@d2eb7a1c443d1539ef12b6f027074a0eb15b1ea0 Reviewed-on: https://github.com/flang-compiler/f18/pull/980
2020-02-25 23:11:52 +08:00
#include "flang/Evaluate/characteristics.h"
#include "flang/Evaluate/check-expression.h"
#include "flang/Evaluate/shape.h"
#include "flang/Evaluate/tools.h"
#include "flang/Parser/characters.h"
#include "flang/Parser/message.h"
#include "flang/Semantics/scope.h"
#include "flang/Semantics/tools.h"
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
#include <map>
#include <string>
using namespace Fortran::parser::literals;
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
namespace characteristics = Fortran::evaluate::characteristics;
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
namespace Fortran::semantics {
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
static void CheckImplicitInterfaceArg(
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
evaluate::ActualArgument &arg, parser::ContextualMessages &messages) {
[flang] Make source location more accurate for actual arguments Track source location information when available for actual arguments to procedure references, and use this information when checking constraints on calls so that error messages refer to specific actual arguments rather than to the entire call. Differential Revision: https://reviews.llvm.org/D119849
2022-02-12 08:58:01 +08:00
auto restorer{
messages.SetLocation(arg.sourceLocation().value_or(messages.at()))};
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
if (auto kw{arg.keyword()}) {
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
messages.Say(*kw,
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
"Keyword '%s=' may not appear in a reference to a procedure with an implicit interface"_err_en_US,
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
*kw);
}
if (auto type{arg.GetType()}) {
if (type->IsAssumedType()) {
messages.Say(
"Assumed type argument requires an explicit interface"_err_en_US);
} else if (type->IsPolymorphic()) {
messages.Say(
"Polymorphic argument requires an explicit interface"_err_en_US);
[flang] Add evaluate::GetDerivedTypeSpec(DynamicType) It gets the semantics::DerivedTypeSpec of a DynamicType if it has one. Make use of it where it simplifies the code. Original-commit: flang-compiler/f18@9ad12e7c131459a8beab2b9ffa204966a85f405a Reviewed-on: https://github.com/flang-compiler/f18/pull/872
2019-12-17 06:28:23 +08:00
} else if (const DerivedTypeSpec * derived{GetDerivedTypeSpec(type)}) {
if (!derived->parameters().empty()) {
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
messages.Say(
"Parameterized derived type argument requires an explicit interface"_err_en_US);
}
}
}
if (const auto *expr{arg.UnwrapExpr()}) {
[flang] Disallow BOZ literal constants as output list items According to C7109, "A boz-literal-constant shall appear only as a data-stmt-constant in a DATA statement, or where explicitly allowed in 16.9 as an actual argument of an intrinsic procedure." This change enforces that constraint for output list items. I also added a general interface to determine if an expression is a BOZ literal constant and changed all of the places I could find where it could be used. I also added a test. This change stemmed from the following issue -- https://gitlab-master.nvidia.com/fortran/f18-stage/issues/108 Differential Revision: https://reviews.llvm.org/D106893
2021-07-28 01:40:34 +08:00
if (IsBOZLiteral(*expr)) {
[flang] Disallow BOZ literal constants as arguments of implicit interfaces Since BOZ literal arguments are typeless, we cannot know how to pass them as actual arguments to procedures with implicit interfaces. This change avoids the problem by emitting an error message in such situations. This change stemmed from the following issue -- https://github.com/flang-compiler/f18-llvm-project/issues/794 Differential Revision: https://reviews.llvm.org/D106831
2021-07-27 05:28:36 +08:00
messages.Say("BOZ argument requires an explicit interface"_err_en_US);
[flang] More checking of NULL pointer actual arguments Catch additional missing error cases for typed and untyped NULL actual arguments to non-intrinsic procedures in cases of explicit and implicit interfaces. Differential Revision: https://reviews.llvm.org/D110003
2021-09-17 23:19:10 +08:00
} else if (evaluate::IsNullPointer(*expr)) {
messages.Say(
"Null pointer argument requires an explicit interface"_err_en_US);
} else if (auto named{evaluate::ExtractNamedEntity(*expr)}) {
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
const Symbol &symbol{named->GetLastSymbol()};
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
if (symbol.Corank() > 0) {
messages.Say(
"Coarray argument requires an explicit interface"_err_en_US);
}
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
if (const auto *details{symbol.detailsIf<ObjectEntityDetails>()}) {
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
if (details->IsAssumedRank()) {
messages.Say(
"Assumed rank argument requires an explicit interface"_err_en_US);
}
}
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
if (symbol.attrs().test(Attr::ASYNCHRONOUS)) {
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
messages.Say(
"ASYNCHRONOUS argument requires an explicit interface"_err_en_US);
}
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
if (symbol.attrs().test(Attr::VOLATILE)) {
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
messages.Say(
"VOLATILE argument requires an explicit interface"_err_en_US);
}
}
}
}
[flang] Pad short CHARACTER actual arguments Original-commit: flang-compiler/f18@b9c890ca9cc3e07967ece4dee739ac8059bb9388 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 06:36:54 +08:00
// When scalar CHARACTER actual arguments are known to be short,
// we extend them on the right with spaces and a warning.
[flang] Upgrade short actual character arguments to errors f18 was emitting a warning about short character actual arguments to subprograms and statement functions; every other compiler considers this case to be an error. Differential Revision: https://reviews.llvm.org/D123731
2022-04-12 09:39:02 +08:00
static void CheckCharacterActual(evaluate::Expr<evaluate::SomeType> &actual,
[flang] Pad short CHARACTER actual arguments Original-commit: flang-compiler/f18@b9c890ca9cc3e07967ece4dee739ac8059bb9388 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 06:36:54 +08:00
const characteristics::TypeAndShape &dummyType,
[flang] Track CHARACTER length better in TypeAndShape CHARACTER length expressions were not always being captured or computed as part of procedure "characteristics", leading to test failures due to an inability to compute memory size expressions accurately. Differential revision: https://reviews.llvm.org/D88689
2020-10-02 02:46:24 +08:00
characteristics::TypeAndShape &actualType,
evaluate::FoldingContext &context, parser::ContextualMessages &messages) {
[flang] Pad short CHARACTER actual arguments Original-commit: flang-compiler/f18@b9c890ca9cc3e07967ece4dee739ac8059bb9388 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 06:36:54 +08:00
if (dummyType.type().category() == TypeCategory::Character &&
actualType.type().category() == TypeCategory::Character &&
dummyType.type().kind() == actualType.type().kind() &&
GetRank(actualType.shape()) == 0) {
[flang] Track CHARACTER length better in TypeAndShape CHARACTER length expressions were not always being captured or computed as part of procedure "characteristics", leading to test failures due to an inability to compute memory size expressions accurately. Differential revision: https://reviews.llvm.org/D88689
2020-10-02 02:46:24 +08:00
if (dummyType.LEN() && actualType.LEN()) {
auto dummyLength{ToInt64(Fold(context, common::Clone(*dummyType.LEN())))};
auto actualLength{
ToInt64(Fold(context, common::Clone(*actualType.LEN())))};
if (dummyLength && actualLength && *actualLength < *dummyLength) {
messages.Say(
[flang] Upgrade short actual character arguments to errors f18 was emitting a warning about short character actual arguments to subprograms and statement functions; every other compiler considers this case to be an error. Differential Revision: https://reviews.llvm.org/D123731
2022-04-12 09:39:02 +08:00
"Actual length '%jd' is less than expected length '%jd'"_err_en_US,
[flang] Track CHARACTER length better in TypeAndShape CHARACTER length expressions were not always being captured or computed as part of procedure "characteristics", leading to test failures due to an inability to compute memory size expressions accurately. Differential revision: https://reviews.llvm.org/D88689
2020-10-02 02:46:24 +08:00
*actualLength, *dummyLength);
[flang] Upgrade short actual character arguments to errors f18 was emitting a warning about short character actual arguments to subprograms and statement functions; every other compiler considers this case to be an error. Differential Revision: https://reviews.llvm.org/D123731
2022-04-12 09:39:02 +08:00
#if 0 // We used to just emit a warning, and padded the actual argument
[flang] Track CHARACTER length better in TypeAndShape CHARACTER length expressions were not always being captured or computed as part of procedure "characteristics", leading to test failures due to an inability to compute memory size expressions accurately. Differential revision: https://reviews.llvm.org/D88689
2020-10-02 02:46:24 +08:00
auto converted{ConvertToType(dummyType.type(), std::move(actual))};
CHECK(converted);
actual = std::move(*converted);
actualType.set_LEN(SubscriptIntExpr{*dummyLength});
[flang] Upgrade short actual character arguments to errors f18 was emitting a warning about short character actual arguments to subprograms and statement functions; every other compiler considers this case to be an error. Differential Revision: https://reviews.llvm.org/D123731
2022-04-12 09:39:02 +08:00
#endif
[flang] Pad short CHARACTER actual arguments Original-commit: flang-compiler/f18@b9c890ca9cc3e07967ece4dee739ac8059bb9388 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 06:36:54 +08:00
}
}
}
}
[flang] Auto conversion of integer scalar actual argument exprs Add documentation Original-commit: flang-compiler/f18@c1b200d23891cff4eca1991deec58c1adf65842e Reviewed-on: https://github.com/flang-compiler/f18/pull/884
2019-12-20 11:13:16 +08:00
// Automatic conversion of different-kind INTEGER scalar actual
// argument expressions (not variables) to INTEGER scalar dummies.
// We return nonstandard INTEGER(8) results from intrinsic functions
// like SIZE() by default in order to facilitate the use of large
// arrays. Emit a warning when downconverting.
static void ConvertIntegerActual(evaluate::Expr<evaluate::SomeType> &actual,
const characteristics::TypeAndShape &dummyType,
characteristics::TypeAndShape &actualType,
parser::ContextualMessages &messages) {
if (dummyType.type().category() == TypeCategory::Integer &&
actualType.type().category() == TypeCategory::Integer &&
dummyType.type().kind() != actualType.type().kind() &&
GetRank(dummyType.shape()) == 0 && GetRank(actualType.shape()) == 0 &&
!evaluate::IsVariable(actual)) {
auto converted{
evaluate::ConvertToType(dummyType.type(), std::move(actual))};
CHECK(converted);
actual = std::move(*converted);
if (dummyType.type().kind() < actualType.type().kind()) {
messages.Say(
[flang] Distinguish usage and portability warning messages Using recently established message severity codes, upgrade non-fatal messages to usage and portability warnings as appropriate. Differential Revision: https://reviews.llvm.org/D121246
2022-03-08 05:57:37 +08:00
"Actual argument scalar expression of type INTEGER(%d) was converted to smaller dummy argument type INTEGER(%d)"_port_en_US,
[flang] Auto conversion of integer scalar actual argument exprs Add documentation Original-commit: flang-compiler/f18@c1b200d23891cff4eca1991deec58c1adf65842e Reviewed-on: https://github.com/flang-compiler/f18/pull/884
2019-12-20 11:13:16 +08:00
actualType.type().kind(), dummyType.type().kind());
}
actualType = dummyType;
}
}
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
static bool DefersSameTypeParameters(
const DerivedTypeSpec &actual, const DerivedTypeSpec &dummy) {
for (const auto &pair : actual.parameters()) {
const ParamValue &actualValue{pair.second};
const ParamValue *dummyValue{dummy.FindParameter(pair.first)};
if (!dummyValue || (actualValue.isDeferred() != dummyValue->isDeferred())) {
return false;
}
}
return true;
}
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
static void CheckExplicitDataArg(const characteristics::DummyDataObject &dummy,
[flang] Pad short CHARACTER actual arguments Original-commit: flang-compiler/f18@b9c890ca9cc3e07967ece4dee739ac8059bb9388 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 06:36:54 +08:00
const std::string &dummyName, evaluate::Expr<evaluate::SomeType> &actual,
[flang] Auto conversion of integer scalar actual argument exprs Add documentation Original-commit: flang-compiler/f18@c1b200d23891cff4eca1991deec58c1adf65842e Reviewed-on: https://github.com/flang-compiler/f18/pull/884
2019-12-20 11:13:16 +08:00
characteristics::TypeAndShape &actualType, bool isElemental,
[flang] Allow NULL() actual argument for pointer dummy Fixes a bogus error message about an actual argument not being an object. Differential Revision: https://reviews.llvm.org/D95176
2021-01-22 06:50:57 +08:00
evaluate::FoldingContext &context, const Scope *scope,
[flang] Fix generic resolution case Don't try to convert INTEGER argument expressions to the kind of the dummy argument when performing generic resolution; specific procedures may be distinguished only by their kinds. Differential Revision: https://reviews.llvm.org/D112240
2021-10-20 02:34:57 +08:00
const evaluate::SpecificIntrinsic *intrinsic,
bool allowIntegerConversions) {
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
// Basic type & rank checking
parser::ContextualMessages &messages{context.messages()};
[flang] Upgrade short actual character arguments to errors f18 was emitting a warning about short character actual arguments to subprograms and statement functions; every other compiler considers this case to be an error. Differential Revision: https://reviews.llvm.org/D123731
2022-04-12 09:39:02 +08:00
CheckCharacterActual(actual, dummy.type, actualType, context, messages);
[flang] Fix generic resolution case Don't try to convert INTEGER argument expressions to the kind of the dummy argument when performing generic resolution; specific procedures may be distinguished only by their kinds. Differential Revision: https://reviews.llvm.org/D112240
2021-10-20 02:34:57 +08:00
if (allowIntegerConversions) {
ConvertIntegerActual(actual, dummy.type, actualType, messages);
}
[flang] Semantic analysis for FINAL subroutines Represent FINAL subroutines in the symbol table entries of derived types. Enforce constraints. Update tests that have inadvertent violations or modified messages. Added a test. The specific procedure distinguishability checking code for generics was used to enforce distinguishability of FINAL procedures. (Also cleaned up some confusion and redundancy noticed in the type compatibility infrastructure while digging into that area.) Differential revision: https://reviews.llvm.org/D88613
2020-10-01 04:34:23 +08:00
bool typesCompatible{dummy.type.type().IsTkCompatibleWith(actualType.type())};
[flang] Fix off-by-one error in preprocessing expressions Original-commit: flang-compiler/f18@4c08a4a1be9fb398a8fc7561da114dc9d2a3accc Reviewed-on: https://github.com/flang-compiler/f18/pull/891
2019-12-21 05:03:30 +08:00
if (typesCompatible) {
if (isElemental) {
} else if (dummy.type.attrs().test(
characteristics::TypeAndShape::Attr::AssumedRank)) {
} else if (!dummy.type.attrs().test(
characteristics::TypeAndShape::Attr::AssumedShape) &&
[flang] Adjust names in Semantics that imply too much (NFC) Some kinds of Fortran arrays are declared with the same syntax, and it is impossible to tell from a shape (:, :) or (*) whether the object is assumed shape, deferred shape, assumed size, implied shape, or whatever without recourse to more information about the symbol in question. This patch softens the names of some predicate functions (IsAssumedShape to CanBeAssumedShape) and makes others more reflective of the syntax they represent (isAssumed to isStar) in an attempt to encourage coders to seek and find definitive predicate functions whose names deliver what they seem to mean. Address TODO comments in IsSimplyContiguous() by using the updated IsAssumedShape() predicate. Differential Revision: https://reviews.llvm.org/D114829
2021-11-27 05:26:50 +08:00
!dummy.type.attrs().test(
characteristics::TypeAndShape::Attr::DeferredShape) &&
[flang] Allow NULL() actual argument for pointer dummy Fixes a bogus error message about an actual argument not being an object. Differential Revision: https://reviews.llvm.org/D95176
2021-01-22 06:50:57 +08:00
(actualType.Rank() > 0 || IsArrayElement(actual))) {
[flang] Fix off-by-one error in preprocessing expressions Original-commit: flang-compiler/f18@4c08a4a1be9fb398a8fc7561da114dc9d2a3accc Reviewed-on: https://github.com/flang-compiler/f18/pull/891
2019-12-21 05:03:30 +08:00
// Sequence association (15.5.2.11) applies -- rank need not match
[flang] Adjust names in Semantics that imply too much (NFC) Some kinds of Fortran arrays are declared with the same syntax, and it is impossible to tell from a shape (:, :) or (*) whether the object is assumed shape, deferred shape, assumed size, implied shape, or whatever without recourse to more information about the symbol in question. This patch softens the names of some predicate functions (IsAssumedShape to CanBeAssumedShape) and makes others more reflective of the syntax they represent (isAssumed to isStar) in an attempt to encourage coders to seek and find definitive predicate functions whose names deliver what they seem to mean. Address TODO comments in IsSimplyContiguous() by using the updated IsAssumedShape() predicate. Differential Revision: https://reviews.llvm.org/D114829
2021-11-27 05:26:50 +08:00
// if the actual argument is an array or array element designator,
// and the dummy is not assumed-shape or an INTENT(IN) pointer
// that's standing in for an assumed-shape dummy.
[flang] Fix off-by-one error in preprocessing expressions Original-commit: flang-compiler/f18@4c08a4a1be9fb398a8fc7561da114dc9d2a3accc Reviewed-on: https://github.com/flang-compiler/f18/pull/891
2019-12-21 05:03:30 +08:00
} else {
[flang] Improve initializer semantics, esp. for component default values This patch plugs many holes in static initializer semantics, improves error messages for default initial values and other component properties in parameterized derived type instantiations, and cleans up several small issues noticed during development. We now do proper scalar expansion, folding, and type, rank, and shape conformance checking for component default initializers in derived types and PDT instantiations. The initial values of named constants are now guaranteed to have been folded when installed in the symbol table, and are no longer folded or scalar-expanded at each use in expression folding. Semantics documentation was extended with information about the various kinds of initializations in Fortran and when each of them are processed in the compiler. Some necessary concomitant changes have bulked this patch out a bit: * contextual messages attachments, which are now produced for parameterized derived type instantiations so that the user can figure out which instance caused a problem with a component, have been added as part of ContextualMessages, and their implementation was debugged * several APIs in evaluate::characteristics was changed so that a FoldingContext is passed as an argument rather than just its intrinsic procedure table; this affected client call sites in many files * new tools in Evaluate/check-expression.cpp to determine when an Expr actually is a single constant value and to validate a non-pointer variable initializer or object component default value * shape conformance checking has additional arguments that control whether scalar expansion is allowed * several now-unused functions and data members noticed and removed * several crashes and bogus errors exposed by testing this new code were fixed * a -fdebug-stack-trace option to enable LLVM's stack tracing on a crash, which might be useful in the future TL;DR: Initialization processing does more and takes place at the right times for all of the various kinds of things that can be initialized. Differential Review: https://reviews.llvm.org/D92783
2020-12-08 04:08:58 +08:00
// Let CheckConformance accept scalars; storage association
// cases are checked here below.
[flang] Fix off-by-one error in preprocessing expressions Original-commit: flang-compiler/f18@4c08a4a1be9fb398a8fc7561da114dc9d2a3accc Reviewed-on: https://github.com/flang-compiler/f18/pull/891
2019-12-21 05:03:30 +08:00
CheckConformance(messages, dummy.type.shape(), actualType.shape(),
[flang] CheckConformance: tristate-ify result To ensure that errors are emitted by CheckConformance and its callers in all situations, it's necessary for the returned result of that function to distinguish between three possible outcomes: the arrays are known to conform at compilation time, the arrays are known to not conform (and a message has been produced), and an indeterminate result in which is not possible to determine conformance. So convert CheckConformance's result into an optional<bool>, and convert its confusing Boolean flag arguments into a bit-set of named flags too. Differential Revision: https://reviews.llvm.org/D103654
2021-06-04 06:48:16 +08:00
evaluate::CheckConformanceFlags::EitherScalarExpandable,
"dummy argument", "actual argument");
[flang] Fix off-by-one error in preprocessing expressions Original-commit: flang-compiler/f18@4c08a4a1be9fb398a8fc7561da114dc9d2a3accc Reviewed-on: https://github.com/flang-compiler/f18/pull/891
2019-12-21 05:03:30 +08:00
}
} else {
[flang] Add `std::string ExpressionBase::AsFortran()` This is easier to use when including an expression in an error message and also useful when debugging for dumping expressions. Fix up several places that no longer need to use a temporary std::stringstream. Also change some references to `operator<<` in `formatting.cc` and `symbol.cc` that became ambiguous with this change. Original-commit: flang-compiler/f18@25dc49b6e9cf5bce61d6d655ab242609cbd28e13 Reviewed-on: https://github.com/flang-compiler/f18/pull/944 Tree-same-pre-rewrite: false
2020-01-15 09:31:25 +08:00
const auto &len{actualType.LEN()};
[flang] Fix off-by-one error in preprocessing expressions Original-commit: flang-compiler/f18@4c08a4a1be9fb398a8fc7561da114dc9d2a3accc Reviewed-on: https://github.com/flang-compiler/f18/pull/891
2019-12-21 05:03:30 +08:00
messages.Say(
"Actual argument type '%s' is not compatible with dummy argument type '%s'"_err_en_US,
[flang] Add `std::string ExpressionBase::AsFortran()` This is easier to use when including an expression in an error message and also useful when debugging for dumping expressions. Fix up several places that no longer need to use a temporary std::stringstream. Also change some references to `operator<<` in `formatting.cc` and `symbol.cc` that became ambiguous with this change. Original-commit: flang-compiler/f18@25dc49b6e9cf5bce61d6d655ab242609cbd28e13 Reviewed-on: https://github.com/flang-compiler/f18/pull/944 Tree-same-pre-rewrite: false
2020-01-15 09:31:25 +08:00
actualType.type().AsFortran(len ? len->AsFortran() : ""),
[flang] Fix off-by-one error in preprocessing expressions Original-commit: flang-compiler/f18@4c08a4a1be9fb398a8fc7561da114dc9d2a3accc Reviewed-on: https://github.com/flang-compiler/f18/pull/891
2019-12-21 05:03:30 +08:00
dummy.type.type().AsFortran());
}
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
bool actualIsPolymorphic{actualType.type().IsPolymorphic()};
bool dummyIsPolymorphic{dummy.type.type().IsPolymorphic()};
bool actualIsCoindexed{ExtractCoarrayRef(actual).has_value()};
bool actualIsAssumedSize{actualType.attrs().test(
characteristics::TypeAndShape::Attr::AssumedSize)};
bool dummyIsAssumedSize{dummy.type.attrs().test(
characteristics::TypeAndShape::Attr::AssumedSize)};
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
bool dummyIsAsynchronous{
dummy.attrs.test(characteristics::DummyDataObject::Attr::Asynchronous)};
bool dummyIsVolatile{
dummy.attrs.test(characteristics::DummyDataObject::Attr::Volatile)};
bool dummyIsValue{
dummy.attrs.test(characteristics::DummyDataObject::Attr::Value)};
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
if (actualIsPolymorphic && dummyIsPolymorphic &&
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
actualIsCoindexed) { // 15.5.2.4(2)
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
messages.Say(
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
"Coindexed polymorphic object may not be associated with a polymorphic %s"_err_en_US,
dummyName);
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
if (actualIsPolymorphic && !dummyIsPolymorphic &&
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
actualIsAssumedSize) { // 15.5.2.4(2)
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
messages.Say(
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
"Assumed-size polymorphic array may not be associated with a monomorphic %s"_err_en_US,
dummyName);
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
// Derived type actual argument checks
[flang] Address most review comments Original-commit: flang-compiler/f18@43720b5057437c77bbe7baa45c7e93ac871e17f9 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-18 01:57:01 +08:00
const Symbol *actualFirstSymbol{evaluate::GetFirstSymbol(actual)};
bool actualIsAsynchronous{
actualFirstSymbol && actualFirstSymbol->attrs().test(Attr::ASYNCHRONOUS)};
bool actualIsVolatile{
actualFirstSymbol && actualFirstSymbol->attrs().test(Attr::VOLATILE)};
[flang] Add evaluate::GetDerivedTypeSpec(DynamicType) It gets the semantics::DerivedTypeSpec of a DynamicType if it has one. Make use of it where it simplifies the code. Original-commit: flang-compiler/f18@9ad12e7c131459a8beab2b9ffa204966a85f405a Reviewed-on: https://github.com/flang-compiler/f18/pull/872
2019-12-17 06:28:23 +08:00
if (const auto *derived{evaluate::GetDerivedTypeSpec(actualType.type())}) {
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
if (dummy.type.type().IsAssumedType()) {
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
if (!derived->parameters().empty()) { // 15.5.2.4(2)
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
messages.Say(
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
"Actual argument associated with TYPE(*) %s may not have a parameterized derived type"_err_en_US,
dummyName);
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
[flang] Use component iterators in check-call.cc Original-commit: flang-compiler/f18@e78db8907f75ebad88b53126b2cfbc743336a8bf Reviewed-on: https://github.com/flang-compiler/f18/pull/782
2019-10-18 06:29:26 +08:00
if (const Symbol *
[flang] Add evaluate::GetDerivedTypeSpec(DynamicType) It gets the semantics::DerivedTypeSpec of a DynamicType if it has one. Make use of it where it simplifies the code. Original-commit: flang-compiler/f18@9ad12e7c131459a8beab2b9ffa204966a85f405a Reviewed-on: https://github.com/flang-compiler/f18/pull/872
2019-12-17 06:28:23 +08:00
tbp{FindImmediateComponent(*derived, [](const Symbol &symbol) {
[flang] Use reference_wrapper in vectors and sets Convert some CharBlock references to values Replace more pointers with reference wrappers Restore object references that were converted to value semantics in an earlier commit Use Reference<> in Scope Fix new component iterator Document pitfall that bit me final tweaks before rebasing and merging Rebasing Original-commit: flang-compiler/f18@87874af934a0344f40374d9288e6805a2757e32f Reviewed-on: https://github.com/flang-compiler/f18/pull/788
2019-10-23 07:53:29 +08:00
return symbol.has<ProcBindingDetails>();
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
})}) { // 15.5.2.4(2)
[flang] Change AttachDeclaration to take reference instead of pointer AttachDeclaration (and so also SayWithDeclaration) don't do anything when passed a null pointer for the symbol and in all but one place they are called the symbol can't be null. So change both function to take `const Symbol &` rather than `const Symbol *`. Change it to handle procedure bindings as well. Add `SayWithDeclaration` to `CheckHelper` to simplify calling the one in `evaluate` and prevent attaching the declaration when it would point at the same line. Original-commit: flang-compiler/f18@5f1c2ff6638da837616fa7ae6e3e121544c89bb7 Reviewed-on: https://github.com/flang-compiler/f18/pull/841 Tree-same-pre-rewrite: false
2019-11-23 05:20:58 +08:00
evaluate::SayWithDeclaration(messages, *tbp,
[flang] Enable and pass test call07.f90 Remove a std::move() Final tweaks after testing and review Original-commit: flang-compiler/f18@b3fe97b1a0cd21b238d8511b44be3feb01823fc4 Reviewed-on: https://github.com/flang-compiler/f18/pull/806
2019-11-02 04:08:16 +08:00
"Actual argument associated with TYPE(*) %s may not have type-bound procedure '%s'"_err_en_US,
dummyName, tbp->name());
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
[flang] Semantic analysis for FINAL subroutines Represent FINAL subroutines in the symbol table entries of derived types. Enforce constraints. Update tests that have inadvertent violations or modified messages. Added a test. The specific procedure distinguishability checking code for generics was used to enforce distinguishability of FINAL procedures. (Also cleaned up some confusion and redundancy noticed in the type compatibility infrastructure while digging into that area.) Differential revision: https://reviews.llvm.org/D88613
2020-10-01 04:34:23 +08:00
const auto &finals{
derived->typeSymbol().get<DerivedTypeDetails>().finals()};
if (!finals.empty()) { // 15.5.2.4(2)
if (auto *msg{messages.Say(
"Actual argument associated with TYPE(*) %s may not have derived type '%s' with FINAL subroutine '%s'"_err_en_US,
dummyName, derived->typeSymbol().name(),
finals.begin()->first)}) {
msg->Attach(finals.begin()->first,
"FINAL subroutine '%s' in derived type '%s'"_en_US,
finals.begin()->first, derived->typeSymbol().name());
}
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
}
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
if (actualIsCoindexed) {
if (dummy.intent != common::Intent::In && !dummyIsValue) {
[flang] Semantic checks for PURE subprograms (test call10.f90) Fix bug found in testing Original-commit: flang-compiler/f18@ccdd7326ba56c5a3cf8bc944516e3d1b93b25848 Reviewed-on: https://github.com/flang-compiler/f18/pull/825
2019-11-13 07:43:09 +08:00
if (auto bad{
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
FindAllocatableUltimateComponent(*derived)}) { // 15.5.2.4(6)
[flang] Change AttachDeclaration to take reference instead of pointer AttachDeclaration (and so also SayWithDeclaration) don't do anything when passed a null pointer for the symbol and in all but one place they are called the symbol can't be null. So change both function to take `const Symbol &` rather than `const Symbol *`. Change it to handle procedure bindings as well. Add `SayWithDeclaration` to `CheckHelper` to simplify calling the one in `evaluate` and prevent attaching the declaration when it would point at the same line. Original-commit: flang-compiler/f18@5f1c2ff6638da837616fa7ae6e3e121544c89bb7 Reviewed-on: https://github.com/flang-compiler/f18/pull/841 Tree-same-pre-rewrite: false
2019-11-23 05:20:58 +08:00
evaluate::SayWithDeclaration(messages, *bad,
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
"Coindexed actual argument with ALLOCATABLE ultimate component '%s' must be associated with a %s with VALUE or INTENT(IN) attributes"_err_en_US,
[flang] Semantic checks for PURE subprograms (test call10.f90) Fix bug found in testing Original-commit: flang-compiler/f18@ccdd7326ba56c5a3cf8bc944516e3d1b93b25848 Reviewed-on: https://github.com/flang-compiler/f18/pull/825
2019-11-13 07:43:09 +08:00
bad.BuildResultDesignatorName(), dummyName);
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
}
}
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
if (auto coarrayRef{evaluate::ExtractCoarrayRef(actual)}) { // C1537
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
const Symbol &coarray{coarrayRef->GetLastSymbol()};
if (const DeclTypeSpec * type{coarray.GetType()}) {
if (const DerivedTypeSpec * derived{type->AsDerived()}) {
[flang] Semantic checks for PURE subprograms (test call10.f90) Fix bug found in testing Original-commit: flang-compiler/f18@ccdd7326ba56c5a3cf8bc944516e3d1b93b25848 Reviewed-on: https://github.com/flang-compiler/f18/pull/825
2019-11-13 07:43:09 +08:00
if (auto bad{semantics::FindPointerUltimateComponent(*derived)}) {
[flang] Change AttachDeclaration to take reference instead of pointer AttachDeclaration (and so also SayWithDeclaration) don't do anything when passed a null pointer for the symbol and in all but one place they are called the symbol can't be null. So change both function to take `const Symbol &` rather than `const Symbol *`. Change it to handle procedure bindings as well. Add `SayWithDeclaration` to `CheckHelper` to simplify calling the one in `evaluate` and prevent attaching the declaration when it would point at the same line. Original-commit: flang-compiler/f18@5f1c2ff6638da837616fa7ae6e3e121544c89bb7 Reviewed-on: https://github.com/flang-compiler/f18/pull/841 Tree-same-pre-rewrite: false
2019-11-23 05:20:58 +08:00
evaluate::SayWithDeclaration(messages, coarray,
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
"Coindexed object '%s' with POINTER ultimate component '%s' cannot be associated with %s"_err_en_US,
[flang] Semantic checks for PURE subprograms (test call10.f90) Fix bug found in testing Original-commit: flang-compiler/f18@ccdd7326ba56c5a3cf8bc944516e3d1b93b25848 Reviewed-on: https://github.com/flang-compiler/f18/pull/825
2019-11-13 07:43:09 +08:00
coarray.name(), bad.BuildResultDesignatorName(), dummyName);
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
}
}
}
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
}
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
if (actualIsVolatile != dummyIsVolatile) { // 15.5.2.4(22)
[flang] Add evaluate::GetDerivedTypeSpec(DynamicType) It gets the semantics::DerivedTypeSpec of a DynamicType if it has one. Make use of it where it simplifies the code. Original-commit: flang-compiler/f18@9ad12e7c131459a8beab2b9ffa204966a85f405a Reviewed-on: https://github.com/flang-compiler/f18/pull/872
2019-12-17 06:28:23 +08:00
if (auto bad{semantics::FindCoarrayUltimateComponent(*derived)}) {
[flang] Change AttachDeclaration to take reference instead of pointer AttachDeclaration (and so also SayWithDeclaration) don't do anything when passed a null pointer for the symbol and in all but one place they are called the symbol can't be null. So change both function to take `const Symbol &` rather than `const Symbol *`. Change it to handle procedure bindings as well. Add `SayWithDeclaration` to `CheckHelper` to simplify calling the one in `evaluate` and prevent attaching the declaration when it would point at the same line. Original-commit: flang-compiler/f18@5f1c2ff6638da837616fa7ae6e3e121544c89bb7 Reviewed-on: https://github.com/flang-compiler/f18/pull/841 Tree-same-pre-rewrite: false
2019-11-23 05:20:58 +08:00
evaluate::SayWithDeclaration(messages, *bad,
[flang] Enable and pass test call07.f90 Remove a std::move() Final tweaks after testing and review Original-commit: flang-compiler/f18@b3fe97b1a0cd21b238d8511b44be3feb01823fc4 Reviewed-on: https://github.com/flang-compiler/f18/pull/806
2019-11-02 04:08:16 +08:00
"VOLATILE attribute must match for %s when actual argument has a coarray ultimate component '%s'"_err_en_US,
[flang] Semantic checks for PURE subprograms (test call10.f90) Fix bug found in testing Original-commit: flang-compiler/f18@ccdd7326ba56c5a3cf8bc944516e3d1b93b25848 Reviewed-on: https://github.com/flang-compiler/f18/pull/825
2019-11-13 07:43:09 +08:00
dummyName, bad.BuildResultDesignatorName());
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
}
}
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
// Rank and shape checks
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
const auto *actualLastSymbol{evaluate::GetLastSymbol(actual)};
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
if (actualLastSymbol) {
[flang] Fix classification of shape inquiries in specification exprs In some contexts, including the motivating case of determining whether the expressions that define the shape of a variable are "constant expressions" in the sense of the Fortran standard, expression rewriting via Fold() is not necessary, and should not be required. The inquiry intrinsics LBOUND, UBOUND, and SIZE work correctly now in specification expressions and are classified correctly as being constant expressions (or not). Getting this right led to a fair amount of API clean-up as a consequence, including the folding of shapes and TypeAndShape objects, and new APIs for shapes that do not fold for those cases where folding isn't needed. Further, the symbol-testing predicate APIs in Evaluate/tools.h now all resolve any associations of their symbols and work transparently on use-, host-, and construct-association symbols; the tools used to resolve those associations have been defined and documented more precisely, and their clients adjusted as needed. Differential Revision: https://reviews.llvm.org/D94561
2021-01-13 07:36:45 +08:00
actualLastSymbol = &ResolveAssociations(*actualLastSymbol);
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
}
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
const ObjectEntityDetails *actualLastObject{actualLastSymbol
[flang] Fix classification of shape inquiries in specification exprs In some contexts, including the motivating case of determining whether the expressions that define the shape of a variable are "constant expressions" in the sense of the Fortran standard, expression rewriting via Fold() is not necessary, and should not be required. The inquiry intrinsics LBOUND, UBOUND, and SIZE work correctly now in specification expressions and are classified correctly as being constant expressions (or not). Getting this right led to a fair amount of API clean-up as a consequence, including the folding of shapes and TypeAndShape objects, and new APIs for shapes that do not fold for those cases where folding isn't needed. Further, the symbol-testing predicate APIs in Evaluate/tools.h now all resolve any associations of their symbols and work transparently on use-, host-, and construct-association symbols; the tools used to resolve those associations have been defined and documented more precisely, and their clients adjusted as needed. Differential Revision: https://reviews.llvm.org/D94561
2021-01-13 07:36:45 +08:00
? actualLastSymbol->detailsIf<ObjectEntityDetails>()
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
: nullptr};
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
int actualRank{evaluate::GetRank(actualType.shape())};
[flang] Allow NULL() actual argument for pointer dummy Fixes a bogus error message about an actual argument not being an object. Differential Revision: https://reviews.llvm.org/D95176
2021-01-22 06:50:57 +08:00
bool actualIsPointer{evaluate::IsObjectPointer(actual, context)};
[flang] Improve shape & length characterization Analyze the shape of the result of TRANSFER(ptr,array) correctly when "ptr" is an array of deferred shape. Fixing this bug led to some refactoring and concentration of common code in TypeAndShape member functions with code in general shape and character length analysis, and this led to some regression test failures that have all been cleaned up. Differential Revision: https://reviews.llvm.org/D95744
2021-01-31 02:14:07 +08:00
bool dummyIsAssumedRank{dummy.type.attrs().test(
characteristics::TypeAndShape::Attr::AssumedRank)};
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
if (dummy.type.attrs().test(
characteristics::TypeAndShape::Attr::AssumedShape)) {
// 15.5.2.4(16)
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
if (actualRank == 0) {
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
messages.Say(
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
"Scalar actual argument may not be associated with assumed-shape %s"_err_en_US,
dummyName);
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
[flang] Change AttachDeclaration to take reference instead of pointer AttachDeclaration (and so also SayWithDeclaration) don't do anything when passed a null pointer for the symbol and in all but one place they are called the symbol can't be null. So change both function to take `const Symbol &` rather than `const Symbol *`. Change it to handle procedure bindings as well. Add `SayWithDeclaration` to `CheckHelper` to simplify calling the one in `evaluate` and prevent attaching the declaration when it would point at the same line. Original-commit: flang-compiler/f18@5f1c2ff6638da837616fa7ae6e3e121544c89bb7 Reviewed-on: https://github.com/flang-compiler/f18/pull/841 Tree-same-pre-rewrite: false
2019-11-23 05:20:58 +08:00
if (actualIsAssumedSize && actualLastSymbol) {
evaluate::SayWithDeclaration(messages, *actualLastSymbol,
[flang] Enable and pass test call07.f90 Remove a std::move() Final tweaks after testing and review Original-commit: flang-compiler/f18@b3fe97b1a0cd21b238d8511b44be3feb01823fc4 Reviewed-on: https://github.com/flang-compiler/f18/pull/806
2019-11-02 04:08:16 +08:00
"Assumed-size array may not be associated with assumed-shape %s"_err_en_US,
dummyName);
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
[flang] Resolve defined operators to specifics Most of these changes involve moving code around so that it case be used for `DefinedUnary` and `DefinedBinary`. The functional changes are in the `Analyze` member functions for those cases where the arguments are now analyzed, the generic is resolved, and a `FunctionRef` is created. Add `ArgumentAnalyzer` to handling building of the `ActualArguments` of a call. This allows the code to be shared with the defined unary and defined binary cases. Move `AnalyzeActualArgument` and `AnalyzeActualArgument` into that class (renaming both to `Analyze`). Create an overload of `GetCalleeAndArguments` for the `Name` case so it can be used for defined ops where we don't have a `ProcedureDesignator`. Move `IsGenericDefinedOp` to `tools.h` to make it available to the new code. We were using `semantics::CheckExplicitInterface` to resolve a generic interface to a specific procedure based on actual arguments. The problem with that is that it performs too many checks. We just want to get the right specific; there may be errors reported later during call analysis. To fix this, add a new function, `CheckInterfaceForGeneric`, to perform this check. It shares code with `CheckExplicitInterface`, but it passes in a null scope to indicate that the full set of checks aren't necessary in `CheckExplicitInterfaceArg`. Instead we lift the call to `TypeAndShape::IsCompatibleWith` out of `CheckExplicitDataArg`, and skip the latter when there is no scope. Original-commit: flang-compiler/f18@fff2d1580f26719e0c384c66576aa6620d04faff Reviewed-on: https://github.com/flang-compiler/f18/pull/786
2019-10-23 00:31:33 +08:00
} else if (actualRank == 0 && dummy.type.Rank() > 0) {
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
// Actual is scalar, dummy is an array. 15.5.2.4(14), 15.5.2.11
if (actualIsCoindexed) {
messages.Say(
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
"Coindexed scalar actual argument must be associated with a scalar %s"_err_en_US,
dummyName);
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
[flang] Do not return true for pointer sub-object in IsPointerObject evaluate::IsPointerObject used to return true for pointer suboject like `pointer(10)` while these object are not pointers. This prevented some checks like 15.5.2.7 to be correctly enforced (e.g., it was possible to pass `pointer(10)` to a non intent(in) dummy pointer). After updating IsPointerObject behavior and adding a test for 15.5.2.7 in call07.f90, a test in call03.f90 for 15.5.2.4(14) was failing. It appeared the related semantics check was relying on IsPointerObject to return true for `pointer(10)`. Adapt the code to detect pointer element in another way. While looking at the code, I also noticed that semantics was rejecting `character(1)` pointer/assumed shape suboject when these are allowed (the standard has a special case for character(1) in 15.5.2.4(14), and I verified that other compilers that enforce 15.5.2.4(14) do accept this). Differential Revision: https://reviews.llvm.org/D121377
2022-03-11 16:22:47 +08:00
bool actualIsArrayElement{IsArrayElement(actual)};
bool actualIsCKindCharacter{
actualType.type().category() == TypeCategory::Character &&
actualType.type().kind() == 1};
if (!actualIsCKindCharacter) {
if (!actualIsArrayElement &&
!(dummy.type.type().IsAssumedType() && dummyIsAssumedSize) &&
!dummyIsAssumedRank) {
messages.Say(
"Whole scalar actual argument may not be associated with a %s array"_err_en_US,
dummyName);
}
if (actualIsPolymorphic) {
messages.Say(
"Polymorphic scalar may not be associated with a %s array"_err_en_US,
dummyName);
}
if (actualIsArrayElement && actualLastSymbol &&
IsPointer(*actualLastSymbol)) {
messages.Say(
"Element of pointer array may not be associated with a %s array"_err_en_US,
dummyName);
}
if (actualLastSymbol && IsAssumedShape(*actualLastSymbol)) {
messages.Say(
"Element of assumed-shape array may not be associated with a %s array"_err_en_US,
dummyName);
}
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
}
[flang] most call04 checks Original-commit: flang-compiler/f18@65289a66d10d21df497b677164bdf26bc10da6b2 Reviewed-on: https://github.com/flang-compiler/f18/pull/783 Tree-same-pre-rewrite: false
2019-10-18 03:28:25 +08:00
if (actualLastObject && actualLastObject->IsCoarray() &&
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
IsAllocatable(*actualLastSymbol) && dummy.intent == common::Intent::Out &&
!(intrinsic &&
evaluate::AcceptsIntentOutAllocatableCoarray(
intrinsic->name))) { // C846
[flang] most call04 checks Original-commit: flang-compiler/f18@65289a66d10d21df497b677164bdf26bc10da6b2 Reviewed-on: https://github.com/flang-compiler/f18/pull/783 Tree-same-pre-rewrite: false
2019-10-18 03:28:25 +08:00
messages.Say(
"ALLOCATABLE coarray '%s' may not be associated with INTENT(OUT) %s"_err_en_US,
actualLastSymbol->name(), dummyName);
}
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
// Definability
[flang] definability tests Original-commit: flang-compiler/f18@4b71f003a9c3a88b4a3e5cbad12f33fb46ef0657 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 04:09:35 +08:00
const char *reason{nullptr};
if (dummy.intent == common::Intent::Out) {
reason = "INTENT(OUT)";
} else if (dummy.intent == common::Intent::InOut) {
reason = "INTENT(IN OUT)";
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
} else if (dummyIsAsynchronous) {
[flang] definability tests Original-commit: flang-compiler/f18@4b71f003a9c3a88b4a3e5cbad12f33fb46ef0657 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 04:09:35 +08:00
reason = "ASYNCHRONOUS";
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
} else if (dummyIsVolatile) {
[flang] definability tests Original-commit: flang-compiler/f18@4b71f003a9c3a88b4a3e5cbad12f33fb46ef0657 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 04:09:35 +08:00
reason = "VOLATILE";
}
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
if (reason && scope) {
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
bool vectorSubscriptIsOk{isElemental || dummyIsValue}; // 15.5.2.4(21)
[flang] Change WhyNotModifiable to return optional One overload of WhyNotModifiable returned an optional message while the other returns a unique_ptr. Change the latter to be consistent with the former and other message-returning functions in this file. Also, reorder the if clauses to reduce the level of indentation. Original-commit: flang-compiler/f18@864e9cfc7ee98e3646052fdc757943011d641691 Reviewed-on: https://github.com/flang-compiler/f18/pull/1050 Tree-same-pre-rewrite: false
2020-03-06 04:56:30 +08:00
if (auto why{WhyNotModifiable(
messages.at(), actual, *scope, vectorSubscriptIsOk)}) {
[flang] definability tests Original-commit: flang-compiler/f18@4b71f003a9c3a88b4a3e5cbad12f33fb46ef0657 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 04:09:35 +08:00
if (auto *msg{messages.Say(
[flang] Semantics for SELECT TYPE Summary: Added support for all semantic checks except C1157 was previously implemented. Address review comments. Reviewers: PeteSteinfeld, tskeith, klausler, DavidTruby, kiranktp, anchu-rajendran, sscalpone Subscribers: kiranchandramohan, llvm-commits, flang-commits Tags: #llvm, #flang Differential Revision: https://reviews.llvm.org/D79851
2020-04-19 19:10:37 +08:00
"Actual argument associated with %s %s must be definable"_err_en_US, // C1158
[flang] Pad short CHARACTER actual arguments Original-commit: flang-compiler/f18@b9c890ca9cc3e07967ece4dee739ac8059bb9388 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 06:36:54 +08:00
reason, dummyName)}) {
[flang] Change WhyNotModifiable to return optional One overload of WhyNotModifiable returned an optional message while the other returns a unique_ptr. Change the latter to be consistent with the former and other message-returning functions in this file. Also, reorder the if clauses to reduce the level of indentation. Original-commit: flang-compiler/f18@864e9cfc7ee98e3646052fdc757943011d641691 Reviewed-on: https://github.com/flang-compiler/f18/pull/1050 Tree-same-pre-rewrite: false
2020-03-06 04:56:30 +08:00
msg->Attach(*why);
[flang] definability tests Original-commit: flang-compiler/f18@4b71f003a9c3a88b4a3e5cbad12f33fb46ef0657 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 04:09:35 +08:00
}
}
}
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
// Cases when temporaries might be needed but must not be permitted.
[flang] Adjust names in Semantics that imply too much (NFC) Some kinds of Fortran arrays are declared with the same syntax, and it is impossible to tell from a shape (:, :) or (*) whether the object is assumed shape, deferred shape, assumed size, implied shape, or whatever without recourse to more information about the symbol in question. This patch softens the names of some predicate functions (IsAssumedShape to CanBeAssumedShape) and makes others more reflective of the syntax they represent (isAssumed to isStar) in an attempt to encourage coders to seek and find definitive predicate functions whose names deliver what they seem to mean. Address TODO comments in IsSimplyContiguous() by using the updated IsAssumedShape() predicate. Differential Revision: https://reviews.llvm.org/D114829
2021-11-27 05:26:50 +08:00
bool actualIsContiguous{IsSimplyContiguous(actual, context)};
bool dummyIsAssumedShape{dummy.type.attrs().test(
characteristics::TypeAndShape::Attr::AssumedShape)};
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
bool dummyIsPointer{
dummy.attrs.test(characteristics::DummyDataObject::Attr::Pointer)};
[flang] Enable and pass test call07.f90 Remove a std::move() Final tweaks after testing and review Original-commit: flang-compiler/f18@b3fe97b1a0cd21b238d8511b44be3feb01823fc4 Reviewed-on: https://github.com/flang-compiler/f18/pull/806
2019-11-02 04:08:16 +08:00
bool dummyIsContiguous{
dummy.attrs.test(characteristics::DummyDataObject::Attr::Contiguous)};
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
if ((actualIsAsynchronous || actualIsVolatile) &&
(dummyIsAsynchronous || dummyIsVolatile) && !dummyIsValue) {
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
if (actualIsCoindexed) { // C1538
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
messages.Say(
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
"Coindexed ASYNCHRONOUS or VOLATILE actual argument may not be associated with %s with ASYNCHRONOUS or VOLATILE attributes unless VALUE"_err_en_US,
dummyName);
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
}
[flang] Enable and pass test call07.f90 Remove a std::move() Final tweaks after testing and review Original-commit: flang-compiler/f18@b3fe97b1a0cd21b238d8511b44be3feb01823fc4 Reviewed-on: https://github.com/flang-compiler/f18/pull/806
2019-11-02 04:08:16 +08:00
if (actualRank > 0 && !actualIsContiguous) {
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
if (dummyIsContiguous ||
!(dummyIsAssumedShape || dummyIsAssumedRank ||
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
(actualIsPointer && dummyIsPointer))) { // C1539 & C1540
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
messages.Say(
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
"ASYNCHRONOUS or VOLATILE actual argument that is not simply contiguous may not be associated with a contiguous %s"_err_en_US,
dummyName);
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
}
}
}
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
// 15.5.2.6 -- dummy is ALLOCATABLE
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
bool dummyIsAllocatable{
dummy.attrs.test(characteristics::DummyDataObject::Attr::Allocatable)};
[flang] add evaluate::IsAllocatableDesignator helper Previously, some semantic checks that are checking if an entity is an allocatable were relying on the expression being a designator whose last symbol has the allocatable attribute. This is wrong since this was considering substrings and array sections of allocatables as being allocatable. This is wrong (see NOTE 2 in Fortran 2018 section 9.5.3.1). Add evaluate::IsAllocatableDesignator to correctly test this. Also add some semantic tests for ALLOCATED to test the newly added helper. Note that ifort and nag are rejecting coindexed-named-object in ALLOCATED (`allocated(coarray_scalar_alloc[2])`). I think it is wrong given allocated argument is intent(in) as per 16.2.1 point 3. So 15.5.2.6 point 4 regarding allocatable dummy is not violated (If the actual argument is a coindexed object, the dummy argument shall have the INTENT (IN) attribute.) and I think this is valid. gfortran accepts it. The need for this helper was exposed in https://reviews.llvm.org/D122779. Differential Revision: https://reviews.llvm.org/D122899 Co-authored-by: Peixin-Qiao <qiaopeixin@huawei.com>
2022-04-02 04:31:23 +08:00
bool actualIsAllocatable{evaluate::IsAllocatableDesignator(actual)};
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
if (dummyIsAllocatable) {
if (!actualIsAllocatable) {
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
messages.Say(
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
"ALLOCATABLE %s must be associated with an ALLOCATABLE actual argument"_err_en_US,
dummyName);
}
if (actualIsAllocatable && actualIsCoindexed &&
dummy.intent != common::Intent::In) {
messages.Say(
"ALLOCATABLE %s must have INTENT(IN) to be associated with a coindexed actual argument"_err_en_US,
dummyName);
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
}
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
if (!actualIsCoindexed && actualLastSymbol &&
actualLastSymbol->Corank() != dummy.type.corank()) {
messages.Say(
"ALLOCATABLE %s has corank %d but actual argument has corank %d"_err_en_US,
dummyName, dummy.type.corank(), actualLastSymbol->Corank());
}
}
[flang] Enable and pass test call07.f90 Remove a std::move() Final tweaks after testing and review Original-commit: flang-compiler/f18@b3fe97b1a0cd21b238d8511b44be3feb01823fc4 Reviewed-on: https://github.com/flang-compiler/f18/pull/806
2019-11-02 04:08:16 +08:00
// 15.5.2.7 -- dummy is POINTER
if (dummyIsPointer) {
if (dummyIsContiguous && !actualIsContiguous) {
messages.Say(
"Actual argument associated with CONTIGUOUS POINTER %s must be simply contiguous"_err_en_US,
dummyName);
}
if (!actualIsPointer) {
if (dummy.intent == common::Intent::In) {
[flang] Move pointer assignment checking to its own file Create `pointer-assignment.{h,cc}` for pointer assignment checking. It doesn't share with assignment checking so it should be its own file. Move the code into semantics namespace. Original-commit: flang-compiler/f18@1658aba81f24fe3913298e76ae8b9c938bd4d248 Reviewed-on: https://github.com/flang-compiler/f18/pull/928 Tree-same-pre-rewrite: false
2020-01-07 01:16:18 +08:00
semantics::CheckPointerAssignment(
[flang] Apply implicit typing to names in COMMON that appear in specification expressions Extend semantic analysis of expressions to catch missing cases Fix statement function semantics, add degree trig intrinsics Add GetUltimate to rewrite of bare namelist Address review comments Original-commit: flang-compiler/f18@52ff319de2e750733660d8e7e938e09159a3c11c Reviewed-on: https://github.com/flang-compiler/f18/pull/871
2019-12-12 07:06:24 +08:00
context, parser::CharBlock{}, dummyName, dummy, actual);
[flang] Enable and pass test call07.f90 Remove a std::move() Final tweaks after testing and review Original-commit: flang-compiler/f18@b3fe97b1a0cd21b238d8511b44be3feb01823fc4 Reviewed-on: https://github.com/flang-compiler/f18/pull/806
2019-11-02 04:08:16 +08:00
} else {
messages.Say(
"Actual argument associated with POINTER %s must also be POINTER unless INTENT(IN)"_err_en_US,
dummyName);
}
}
}
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
// 15.5.2.5 -- actual & dummy are both POINTER or both ALLOCATABLE
if ((actualIsPointer && dummyIsPointer) ||
(actualIsAllocatable && dummyIsAllocatable)) {
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
bool actualIsUnlimited{actualType.type().IsUnlimitedPolymorphic()};
bool dummyIsUnlimited{dummy.type.type().IsUnlimitedPolymorphic()};
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
if (actualIsUnlimited != dummyIsUnlimited) {
if (typesCompatible) {
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
messages.Say(
"If a POINTER or ALLOCATABLE dummy or actual argument is unlimited polymorphic, both must be so"_err_en_US);
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
}
} else if (dummyIsPolymorphic != actualIsPolymorphic) {
if (dummy.intent == common::Intent::In && typesCompatible) {
// extension: allow with warning, rule is only relevant for definables
messages.Say(
[flang] Distinguish usage and portability warning messages Using recently established message severity codes, upgrade non-fatal messages to usage and portability warnings as appropriate. Differential Revision: https://reviews.llvm.org/D121246
2022-03-08 05:57:37 +08:00
"If a POINTER or ALLOCATABLE dummy or actual argument is polymorphic, both should be so"_port_en_US);
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
} else {
messages.Say(
"If a POINTER or ALLOCATABLE dummy or actual argument is polymorphic, both must be so"_err_en_US);
}
} else if (!actualIsUnlimited && typesCompatible) {
[flang] Semantic analysis for FINAL subroutines Represent FINAL subroutines in the symbol table entries of derived types. Enforce constraints. Update tests that have inadvertent violations or modified messages. Added a test. The specific procedure distinguishability checking code for generics was used to enforce distinguishability of FINAL procedures. (Also cleaned up some confusion and redundancy noticed in the type compatibility infrastructure while digging into that area.) Differential revision: https://reviews.llvm.org/D88613
2020-10-01 04:34:23 +08:00
if (!actualType.type().IsTkCompatibleWith(dummy.type.type())) {
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
if (dummy.intent == common::Intent::In) {
// extension: allow with warning, rule is only relevant for definables
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
messages.Say(
[flang] Distinguish usage and portability warning messages Using recently established message severity codes, upgrade non-fatal messages to usage and portability warnings as appropriate. Differential Revision: https://reviews.llvm.org/D121246
2022-03-08 05:57:37 +08:00
"POINTER or ALLOCATABLE dummy and actual arguments should have the same declared type and kind"_port_en_US);
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
} else {
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
messages.Say(
[flang] Semantic analysis for FINAL subroutines Represent FINAL subroutines in the symbol table entries of derived types. Enforce constraints. Update tests that have inadvertent violations or modified messages. Added a test. The specific procedure distinguishability checking code for generics was used to enforce distinguishability of FINAL procedures. (Also cleaned up some confusion and redundancy noticed in the type compatibility infrastructure while digging into that area.) Differential revision: https://reviews.llvm.org/D88613
2020-10-01 04:34:23 +08:00
"POINTER or ALLOCATABLE dummy and actual arguments must have the same declared type and kind"_err_en_US);
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
}
}
[flang] Add one semantic check for allocatable/pointer argument association The actual argument shall have deferred the same type parameters as the dummy argument if the argument is allocatable or pointer variable. Currently programs not following this get one crash during execution. Reviewed By: Jean Perier Differential Revision: https://reviews.llvm.org/D122779
2022-04-04 23:16:30 +08:00
// 15.5.2.5(4)
[flang] Add evaluate::GetDerivedTypeSpec(DynamicType) It gets the semantics::DerivedTypeSpec of a DynamicType if it has one. Make use of it where it simplifies the code. Original-commit: flang-compiler/f18@9ad12e7c131459a8beab2b9ffa204966a85f405a Reviewed-on: https://github.com/flang-compiler/f18/pull/872
2019-12-17 06:28:23 +08:00
if (const auto *derived{
evaluate::GetDerivedTypeSpec(actualType.type())}) {
if (!DefersSameTypeParameters(
*derived, *evaluate::GetDerivedTypeSpec(dummy.type.type()))) {
messages.Say(
"Dummy and actual arguments must defer the same type parameters when POINTER or ALLOCATABLE"_err_en_US);
}
[flang] Add one semantic check for allocatable/pointer argument association The actual argument shall have deferred the same type parameters as the dummy argument if the argument is allocatable or pointer variable. Currently programs not following this get one crash during execution. Reviewed By: Jean Perier Differential Revision: https://reviews.llvm.org/D122779
2022-04-04 23:16:30 +08:00
} else if (dummy.type.type().HasDeferredTypeParameter() !=
actualType.type().HasDeferredTypeParameter()) {
messages.Say(
"Dummy and actual arguments must defer the same type parameters when POINTER or ALLOCATABLE"_err_en_US);
[flang] enable call06.f90 test Relax checking when irrelevant due to INTENT(IN) Add and pass call14.f90 test on VALUE Allow ASYNCHRONOUS/VOLATILE to apply to host/USE associated entities, add tests Pass call06 Check C827 & C828, fix tests Original-commit: flang-compiler/f18@df6cb83794b4f8842170c748d9edb7b53ba56fe8 Reviewed-on: https://github.com/flang-compiler/f18/pull/801
2019-10-30 03:46:25 +08:00
}
[flang] Restored changes from pmk-call05 Original-commit: flang-compiler/f18@bb9c12eec36e7737ebc20b17d7e51da127aa1fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:08:06 +08:00
}
}
[flang] Enable and pass call08.f90 Refine a check Original-commit: flang-compiler/f18@bb96c195d4d6825041912d8ab0b5c5fb7f9418e2 Reviewed-on: https://github.com/flang-compiler/f18/pull/812
2019-11-05 06:06:52 +08:00
// 15.5.2.8 -- coarray dummy arguments
if (dummy.type.corank() > 0) {
if (actualType.corank() == 0) {
messages.Say(
"Actual argument associated with coarray %s must be a coarray"_err_en_US,
dummyName);
}
if (dummyIsVolatile) {
if (!actualIsVolatile) {
messages.Say(
"non-VOLATILE coarray may not be associated with VOLATILE coarray %s"_err_en_US,
dummyName);
}
} else {
if (actualIsVolatile) {
messages.Say(
"VOLATILE coarray may not be associated with non-VOLATILE coarray %s"_err_en_US,
dummyName);
}
}
if (actualRank == dummy.type.Rank() && !actualIsContiguous) {
if (dummyIsContiguous) {
messages.Say(
"Actual argument associated with a CONTIGUOUS coarray %s must be simply contiguous"_err_en_US,
dummyName);
} else if (!dummyIsAssumedShape && !dummyIsAssumedRank) {
messages.Say(
"Actual argument associated with coarray %s (not assumed shape or rank) must be simply contiguous"_err_en_US,
dummyName);
}
}
}
[flang] More checking of NULL pointer actual arguments Catch additional missing error cases for typed and untyped NULL actual arguments to non-intrinsic procedures in cases of explicit and implicit interfaces. Differential Revision: https://reviews.llvm.org/D110003
2021-09-17 23:19:10 +08:00
// NULL(MOLD=) checking for non-intrinsic procedures
bool dummyIsOptional{
dummy.attrs.test(characteristics::DummyDataObject::Attr::Optional)};
bool actualIsNull{evaluate::IsNullPointer(actual)};
if (!intrinsic && !dummyIsPointer && !dummyIsOptional && actualIsNull) {
messages.Say(
"Actual argument associated with %s may not be null pointer %s"_err_en_US,
dummyName, actual.AsFortran());
}
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
}
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
static void CheckProcedureArg(evaluate::ActualArgument &arg,
[flang] Upgrade warning to error in case of PURE procedure A procedure actual argument to a PURE procedure should be required to have an explicit interface. Implicit-interface actual arguments to non-PURE procedures remain a warning. Differential Revision: https://reviews.llvm.org/D109926
2021-09-15 03:44:57 +08:00
const characteristics::Procedure &proc,
const characteristics::DummyProcedure &dummy, const std::string &dummyName,
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
evaluate::FoldingContext &context) {
parser::ContextualMessages &messages{context.messages()};
[flang] Make source location more accurate for actual arguments Track source location information when available for actual arguments to procedure references, and use this information when checking constraints on calls so that error messages refer to specific actual arguments rather than to the entire call. Differential Revision: https://reviews.llvm.org/D119849
2022-02-12 08:58:01 +08:00
auto restorer{
messages.SetLocation(arg.sourceLocation().value_or(messages.at()))};
[flang] Upgrade warning to error in case of PURE procedure A procedure actual argument to a PURE procedure should be required to have an explicit interface. Implicit-interface actual arguments to non-PURE procedures remain a warning. Differential Revision: https://reviews.llvm.org/D109926
2021-09-15 03:44:57 +08:00
const characteristics::Procedure &interface { dummy.procedure.value() };
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
if (const auto *expr{arg.UnwrapExpr()}) {
bool dummyIsPointer{
[flang] Upgrade warning to error in case of PURE procedure A procedure actual argument to a PURE procedure should be required to have an explicit interface. Implicit-interface actual arguments to non-PURE procedures remain a warning. Differential Revision: https://reviews.llvm.org/D109926
2021-09-15 03:44:57 +08:00
dummy.attrs.test(characteristics::DummyProcedure::Attr::Pointer)};
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
const auto *argProcDesignator{
std::get_if<evaluate::ProcedureDesignator>(&expr->u)};
const auto *argProcSymbol{
argProcDesignator ? argProcDesignator->GetSymbol() : nullptr};
if (auto argChars{characteristics::DummyArgument::FromActual(
"actual argument", *expr, context)}) {
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
if (!argChars->IsTypelessIntrinsicDummy()) {
if (auto *argProc{
std::get_if<characteristics::DummyProcedure>(&argChars->u)}) {
characteristics::Procedure &argInterface{argProc->procedure.value()};
argInterface.attrs.reset(
characteristics::Procedure::Attr::NullPointer);
if (!argProcSymbol || argProcSymbol->attrs().test(Attr::INTRINSIC)) {
// It's ok to pass ELEMENTAL unrestricted intrinsic functions.
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
argInterface.attrs.reset(
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
characteristics::Procedure::Attr::Elemental);
} else if (argInterface.attrs.test(
characteristics::Procedure::Attr::Elemental)) {
if (argProcSymbol) { // C1533
evaluate::SayWithDeclaration(messages, *argProcSymbol,
"Non-intrinsic ELEMENTAL procedure '%s' may not be passed as an actual argument"_err_en_US,
argProcSymbol->name());
return; // avoid piling on with checks below
} else {
argInterface.attrs.reset(
characteristics::Procedure::Attr::NullPointer);
}
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
}
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
if (interface.HasExplicitInterface()) {
[flang] Remove bogus messages for actual/dummy procedure argument compatibility Add new IsCompatibleWith() member functions to many classes in evaluate::characteristics that apply more nuanced compatibility checking for function results, dummy arguments, and procedure interfaces than the previous tests for complete equivalence. Use IsCompatibleWith() in semantics for call checking. Differential Revision: https://reviews.llvm.org/D120844
2022-02-24 08:36:39 +08:00
if (!interface.IsCompatibleWith(argInterface)) {
[flang] Add tests for procedure arguments with implicit interfaces It's possible to declare an external procedure and then pass it as an actual argument to a subprogram expecting a procedure argument. I added tests for this and added an error message to distinguish passing an actual argument with an implicit interface from passing an argument with a mismatched explicit interface. Differential Revision: https://reviews.llvm.org/D94505
2021-01-13 00:52:27 +08:00
// 15.5.2.9(1): Explicit interfaces must match
if (argInterface.HasExplicitInterface()) {
messages.Say(
"Actual procedure argument has interface incompatible with %s"_err_en_US,
dummyName);
return;
[flang] Upgrade warning to error in case of PURE procedure A procedure actual argument to a PURE procedure should be required to have an explicit interface. Implicit-interface actual arguments to non-PURE procedures remain a warning. Differential Revision: https://reviews.llvm.org/D109926
2021-09-15 03:44:57 +08:00
} else if (proc.IsPure()) {
messages.Say(
"Actual procedure argument for %s of a PURE procedure must have an explicit interface"_err_en_US,
dummyName);
[flang] Add tests for procedure arguments with implicit interfaces It's possible to declare an external procedure and then pass it as an actual argument to a subprogram expecting a procedure argument. I added tests for this and added an error message to distinguish passing an actual argument with an implicit interface from passing an argument with a mismatched explicit interface. Differential Revision: https://reviews.llvm.org/D94505
2021-01-13 00:52:27 +08:00
} else {
messages.Say(
"Actual procedure argument has an implicit interface "
"which is not known to be compatible with %s which has an "
[flang] Distinguish usage and portability warning messages Using recently established message severity codes, upgrade non-fatal messages to usage and portability warnings as appropriate. Differential Revision: https://reviews.llvm.org/D121246
2022-03-08 05:57:37 +08:00
"explicit interface"_warn_en_US,
[flang] Add tests for procedure arguments with implicit interfaces It's possible to declare an external procedure and then pass it as an actual argument to a subprogram expecting a procedure argument. I added tests for this and added an error message to distinguish passing an actual argument with an implicit interface from passing an argument with a mismatched explicit interface. Differential Revision: https://reviews.llvm.org/D94505
2021-01-13 00:52:27 +08:00
dummyName);
}
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
}
} else { // 15.5.2.9(2,3)
if (interface.IsSubroutine() && argInterface.IsFunction()) {
messages.Say(
"Actual argument associated with procedure %s is a function but must be a subroutine"_err_en_US,
dummyName);
} else if (interface.IsFunction()) {
if (argInterface.IsFunction()) {
[flang] Remove bogus messages for actual/dummy procedure argument compatibility Add new IsCompatibleWith() member functions to many classes in evaluate::characteristics that apply more nuanced compatibility checking for function results, dummy arguments, and procedure interfaces than the previous tests for complete equivalence. Use IsCompatibleWith() in semantics for call checking. Differential Revision: https://reviews.llvm.org/D120844
2022-02-24 08:36:39 +08:00
if (!interface.functionResult->IsCompatibleWith(
*argInterface.functionResult)) {
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
messages.Say(
"Actual argument function associated with procedure %s has incompatible result type"_err_en_US,
dummyName);
}
} else if (argInterface.IsSubroutine()) {
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
messages.Say(
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
"Actual argument associated with procedure %s is a subroutine but must be a function"_err_en_US,
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
dummyName);
}
}
}
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
} else {
messages.Say(
"Actual argument associated with procedure %s is not a procedure"_err_en_US,
dummyName);
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
}
[flang] Ensure pointer function results are acceptable variables Fortran permits a reference to a function whose result is a pointer to be used as a definable variable in any context where a designator could appear. This patch wrings out remaining bugs with such usage and adds more testing. The utility predicate IsProcedurePointer(expr) had a misleading name which has been corrected to IsProcedurePointerTarget(expr). Differential Revision: https://reviews.llvm.org/D98555
2021-03-13 05:51:33 +08:00
} else if (IsNullPointer(*expr)) {
if (!dummyIsPointer) {
messages.Say(
"Actual argument associated with procedure %s is a null pointer"_err_en_US,
dummyName);
}
} else {
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
messages.Say(
[flang] Ensure pointer function results are acceptable variables Fortran permits a reference to a function whose result is a pointer to be used as a definable variable in any context where a designator could appear. This patch wrings out remaining bugs with such usage and adds more testing. The utility predicate IsProcedurePointer(expr) had a misleading name which has been corrected to IsProcedurePointerTarget(expr). Differential Revision: https://reviews.llvm.org/D98555
2021-03-13 05:51:33 +08:00
"Actual argument associated with procedure %s is typeless"_err_en_US,
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
dummyName);
}
}
[flang] Ensure pointer function results are acceptable variables Fortran permits a reference to a function whose result is a pointer to be used as a definable variable in any context where a designator could appear. This patch wrings out remaining bugs with such usage and adds more testing. The utility predicate IsProcedurePointer(expr) had a misleading name which has been corrected to IsProcedurePointerTarget(expr). Differential Revision: https://reviews.llvm.org/D98555
2021-03-13 05:51:33 +08:00
if (interface.HasExplicitInterface() && dummyIsPointer &&
[flang] Upgrade warning to error in case of PURE procedure A procedure actual argument to a PURE procedure should be required to have an explicit interface. Implicit-interface actual arguments to non-PURE procedures remain a warning. Differential Revision: https://reviews.llvm.org/D109926
2021-09-15 03:44:57 +08:00
dummy.intent != common::Intent::In) {
[flang] Ensure pointer function results are acceptable variables Fortran permits a reference to a function whose result is a pointer to be used as a definable variable in any context where a designator could appear. This patch wrings out remaining bugs with such usage and adds more testing. The utility predicate IsProcedurePointer(expr) had a misleading name which has been corrected to IsProcedurePointerTarget(expr). Differential Revision: https://reviews.llvm.org/D98555
2021-03-13 05:51:33 +08:00
const Symbol *last{GetLastSymbol(*expr)};
if (!(last && IsProcedurePointer(*last))) {
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
// 15.5.2.9(5) -- dummy procedure POINTER
[flang] Remove bogus messages for actual/dummy procedure argument compatibility Add new IsCompatibleWith() member functions to many classes in evaluate::characteristics that apply more nuanced compatibility checking for function results, dummy arguments, and procedure interfaces than the previous tests for complete equivalence. Use IsCompatibleWith() in semantics for call checking. Differential Revision: https://reviews.llvm.org/D120844
2022-02-24 08:36:39 +08:00
// Interface compatibility has already been checked above
[flang] Ensure pointer function results are acceptable variables Fortran permits a reference to a function whose result is a pointer to be used as a definable variable in any context where a designator could appear. This patch wrings out remaining bugs with such usage and adds more testing. The utility predicate IsProcedurePointer(expr) had a misleading name which has been corrected to IsProcedurePointerTarget(expr). Differential Revision: https://reviews.llvm.org/D98555
2021-03-13 05:51:33 +08:00
messages.Say(
"Actual argument associated with procedure pointer %s must be a POINTER unless INTENT(IN)"_err_en_US,
dummyName);
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
}
}
} else {
messages.Say(
"Assumed-type argument may not be forwarded as procedure %s"_err_en_US,
dummyName);
}
}
[flang] Accept BOZ literals for some actual arguments Consistent with previously documented policy, in which BOZ literals are accepted in non-standard-conforming circumstances where they can be converted to an unambiguous known numeric type, allow BOZ literals to be passed as an actual argument in a reference to a procedure whose explicit interface has a corresponding dummy argument with a numeric type to which the BOZ literal may be converted. Improve error messages associated with BOZ literal actual arguments, too: don't emit multiple errors. Differential Revision: https://reviews.llvm.org/D117698
2022-01-12 02:38:26 +08:00
// Allow BOZ literal actual arguments when they can be converted to a known
// dummy argument type
static void ConvertBOZLiteralArg(
evaluate::ActualArgument &arg, const evaluate::DynamicType &type) {
if (auto *expr{arg.UnwrapExpr()}) {
if (IsBOZLiteral(*expr)) {
if (auto converted{evaluate::ConvertToType(type, SomeExpr{*expr})}) {
arg = std::move(*converted);
}
}
}
}
[flang] Pad short CHARACTER actual arguments Original-commit: flang-compiler/f18@b9c890ca9cc3e07967ece4dee739ac8059bb9388 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 06:36:54 +08:00
static void CheckExplicitInterfaceArg(evaluate::ActualArgument &arg,
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
const characteristics::DummyArgument &dummy,
[flang] pass call03 Original-commit: flang-compiler/f18@8c076bd89b30351b0b6470f4cf621efed1c2ae27 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 07:06:05 +08:00
const characteristics::Procedure &proc, evaluate::FoldingContext &context,
[flang] Fix generic resolution case Don't try to convert INTEGER argument expressions to the kind of the dummy argument when performing generic resolution; specific procedures may be distinguished only by their kinds. Differential Revision: https://reviews.llvm.org/D112240
2021-10-20 02:34:57 +08:00
const Scope *scope, const evaluate::SpecificIntrinsic *intrinsic,
bool allowIntegerConversions) {
[flang] checkpoint checkpoint checkpoint Original-commit: flang-compiler/f18@99d12a7215089b4aefdaef39a2407b84538c29ef Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-09 06:21:09 +08:00
auto &messages{context.messages()};
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
std::string dummyName{"dummy argument"};
if (!dummy.name.empty()) {
dummyName += " '"s + parser::ToLowerCaseLetters(dummy.name) + "='";
}
[flang] Make source location more accurate for actual arguments Track source location information when available for actual arguments to procedure references, and use this information when checking constraints on calls so that error messages refer to specific actual arguments rather than to the entire call. Differential Revision: https://reviews.llvm.org/D119849
2022-02-12 08:58:01 +08:00
auto restorer{
messages.SetLocation(arg.sourceLocation().value_or(messages.at()))};
[flang] Add & use a better visit() (take 2) Adds flang/include/flang/Common/log2-visit.h, which defines a Fortran::common::visit() template function that is a drop-in replacement for std::visit(). Modifies most use sites in the front-end and runtime to use common::visit(). The C++ standard mandates that std::visit() have O(1) execution time, which forces implementations to build dispatch tables. This new common::visit() is O(log2 N) in the number of alternatives in a variant<>, but that N tends to be small and so this change produces a fairly significant improvement in compiler build memory requirements, a 5-10% improvement in compiler build time, and a small improvement in compiler execution time. Building with -DFLANG_USE_STD_VISIT causes common::visit() to be an alias for std::visit(). Calls to common::visit() with multiple variant arguments are referred to std::visit(), pending further work. This change is enabled only for GCC builds with GCC >= 9; an earlier attempt (D122441) ran into bugs in some versions of clang and was reverted rather than simply disabled; and it is not well tested with MSVC. In non-GCC and older GCC builds, common::visit() is simply an alias for std::visit().
2022-03-24 05:05:50 +08:00
common::visit(
[flang] Fix some bugs exposed by testing new checks Original-commit: flang-compiler/f18@9cc70dcad64a77bb67cdb30f157a00898227f727 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 00:39:37 +08:00
common::visitors{
[&](const characteristics::DummyDataObject &object) {
[flang] Accept BOZ literals for some actual arguments Consistent with previously documented policy, in which BOZ literals are accepted in non-standard-conforming circumstances where they can be converted to an unambiguous known numeric type, allow BOZ literals to be passed as an actual argument in a reference to a procedure whose explicit interface has a corresponding dummy argument with a numeric type to which the BOZ literal may be converted. Improve error messages associated with BOZ literal actual arguments, too: don't emit multiple errors. Differential Revision: https://reviews.llvm.org/D117698
2022-01-12 02:38:26 +08:00
ConvertBOZLiteralArg(arg, object.type.type());
[flang] Pad short CHARACTER actual arguments Original-commit: flang-compiler/f18@b9c890ca9cc3e07967ece4dee739ac8059bb9388 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 06:36:54 +08:00
if (auto *expr{arg.UnwrapExpr()}) {
[flang] Fix some bugs exposed by testing new checks Original-commit: flang-compiler/f18@9cc70dcad64a77bb67cdb30f157a00898227f727 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 00:39:37 +08:00
if (auto type{characteristics::TypeAndShape::Characterize(
*expr, context)}) {
[flang] Check for passing DO variables to OUT arguments in a CALL statement I added code to save the INTENT of a dummy argument in the checked expression of the actual argument. When processing a CallStmt, I then retrieve the ProcedureRef, which contains a list of the checked ActualArguments. I then traverse this list looking for actual arguments that are active DO variable that are being passed to dummy arguments whose INTENT is either OUT or INOUT. For OUT dummies, I put out an error message and warn for INOUT dummies. Original-commit: flang-compiler/f18@0ff1d264284c51a0142df0b785eb5f6409e8ad51 Reviewed-on: https://github.com/flang-compiler/f18/pull/902
2020-01-03 04:26:47 +08:00
arg.set_dummyIntent(object.intent);
[flang] Resolve defined operators to specifics Most of these changes involve moving code around so that it case be used for `DefinedUnary` and `DefinedBinary`. The functional changes are in the `Analyze` member functions for those cases where the arguments are now analyzed, the generic is resolved, and a `FunctionRef` is created. Add `ArgumentAnalyzer` to handling building of the `ActualArguments` of a call. This allows the code to be shared with the defined unary and defined binary cases. Move `AnalyzeActualArgument` and `AnalyzeActualArgument` into that class (renaming both to `Analyze`). Create an overload of `GetCalleeAndArguments` for the `Name` case so it can be used for defined ops where we don't have a `ProcedureDesignator`. Move `IsGenericDefinedOp` to `tools.h` to make it available to the new code. We were using `semantics::CheckExplicitInterface` to resolve a generic interface to a specific procedure based on actual arguments. The problem with that is that it performs too many checks. We just want to get the right specific; there may be errors reported later during call analysis. To fix this, add a new function, `CheckInterfaceForGeneric`, to perform this check. It shares code with `CheckExplicitInterface`, but it passes in a null scope to indicate that the full set of checks aren't necessary in `CheckExplicitInterfaceArg`. Instead we lift the call to `TypeAndShape::IsCompatibleWith` out of `CheckExplicitDataArg`, and skip the latter when there is no scope. Original-commit: flang-compiler/f18@fff2d1580f26719e0c384c66576aa6620d04faff Reviewed-on: https://github.com/flang-compiler/f18/pull/786
2019-10-23 00:31:33 +08:00
bool isElemental{object.type.Rank() == 0 && proc.IsElemental()};
[flang] Fix duplicate messages Original-commit: flang-compiler/f18@6528c5f31b8ee9a281b672927a636cee67381d4e Reviewed-on: https://github.com/flang-compiler/f18/pull/792 Tree-same-pre-rewrite: false
2019-10-25 07:38:09 +08:00
CheckExplicitDataArg(object, dummyName, *expr, *type,
[flang] Fix generic resolution case Don't try to convert INTEGER argument expressions to the kind of the dummy argument when performing generic resolution; specific procedures may be distinguished only by their kinds. Differential Revision: https://reviews.llvm.org/D112240
2021-10-20 02:34:57 +08:00
isElemental, context, scope, intrinsic,
allowIntegerConversions);
[flang] Fix some bugs exposed by testing new checks Original-commit: flang-compiler/f18@9cc70dcad64a77bb67cdb30f157a00898227f727 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 00:39:37 +08:00
} else if (object.type.type().IsTypelessIntrinsicArgument() &&
[flang] Disallow BOZ literal constants as output list items According to C7109, "A boz-literal-constant shall appear only as a data-stmt-constant in a DATA statement, or where explicitly allowed in 16.9 as an actual argument of an intrinsic procedure." This change enforces that constraint for output list items. I also added a general interface to determine if an expression is a BOZ literal constant and changed all of the places I could find where it could be used. I also added a test. This change stemmed from the following issue -- https://gitlab-master.nvidia.com/fortran/f18-stage/issues/108 Differential Revision: https://reviews.llvm.org/D106893
2021-07-28 01:40:34 +08:00
IsBOZLiteral(*expr)) {
[flang] Fix some bugs exposed by testing new checks Original-commit: flang-compiler/f18@9cc70dcad64a77bb67cdb30f157a00898227f727 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 00:39:37 +08:00
// ok
[flang] Failed call to CHECK() for call to ASSOCIATED(NULL()) Calling "ASSOCATED(NULL()) was causing an internal check of the compiler to fail. I fixed this by changing the entry for "ASSOCIATED" in the intrinsics table to accept "AnyPointer" which contains a new "KindCode" of "pointerType". I also changed the function "FromActual()" to return a typeless intrinsic when called on a pointer, which duplicates its behavior for BOZ literals. This required changing the analysis of procedure arguments. While testing processing for procedure arguments, I found another bad call to `CHECK()` which I fixed. I made several other changes: -- I implemented constant folding for ASSOCIATED(). -- I fixed handling of NULL() in relational operations. -- I implemented semantic analysis for ASSOCIATED(). -- I noticed that the semantics for ASSOCIATED() are similar to those for pointer assignment. So I extracted the code that pointer assignment uses for procedure pointer compatibility to a place where it could be used by the semantic analysis for ASSOCIATED(). -- I couldn't figure out how to make the general semantic analysis for procedure arguments work with ASSOCIATED()'s second argument, which can be either a pointer or a target. So I stopped using normal semantic analysis for arguments for ASSOCIATED(). -- I added tests for all of this. Differential Revision: https://reviews.llvm.org/D88313
2020-09-26 00:03:17 +08:00
} else if (object.type.type().IsTypelessIntrinsicArgument() &&
evaluate::IsNullPointer(*expr)) {
[flang] Allow NULL() actual argument for pointer dummy Fixes a bogus error message about an actual argument not being an object. Differential Revision: https://reviews.llvm.org/D95176
2021-01-22 06:50:57 +08:00
// ok, ASSOCIATED(NULL())
[flang] More checking of NULL pointer actual arguments Catch additional missing error cases for typed and untyped NULL actual arguments to non-intrinsic procedures in cases of explicit and implicit interfaces. Differential Revision: https://reviews.llvm.org/D110003
2021-09-17 23:19:10 +08:00
} else if ((object.attrs.test(characteristics::DummyDataObject::
Attr::Pointer) ||
object.attrs.test(characteristics::
DummyDataObject::Attr::Optional)) &&
[flang] Allow NULL() actual argument for pointer dummy Fixes a bogus error message about an actual argument not being an object. Differential Revision: https://reviews.llvm.org/D95176
2021-01-22 06:50:57 +08:00
evaluate::IsNullPointer(*expr)) {
// ok, FOO(NULL())
[flang] Fix some bugs exposed by testing new checks Original-commit: flang-compiler/f18@9cc70dcad64a77bb67cdb30f157a00898227f727 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 00:39:37 +08:00
} else {
messages.Say(
[flang] Shape analysis for result of MATMUL Implement shape analysis for the result of the MATMUL generic transformational intrinsic function, based on the shapes of its arguments. Correct the names of the arguments to match the standard, too. Reviewed By: PeteSteinfeld Differential Revision: https://reviews.llvm.org/D82250
2020-06-20 09:11:46 +08:00
"Actual argument '%s' associated with %s is not a variable or typed expression"_err_en_US,
expr->AsFortran(), dummyName);
[flang] Fix some bugs exposed by testing new checks Original-commit: flang-compiler/f18@9cc70dcad64a77bb67cdb30f157a00898227f727 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 00:39:37 +08:00
}
[flang] Semantic checks for C709, C710, and C711 C709 An assumed-type entity shall be a dummy data object that does not have the ALLOCATABLE, CODIMENSION, INTENT (OUT), POINTER, or VALUE attribute and is not an explicit-shape array. C710 An assumed-type variable name shall not appear in a designator or expression except as an actual argument corresponding to a dummy argument that is assumed-type, or as the first argument to the intrinsic function IS_CONTIGUOUS, LBOUND, PRESENT, RANK, SHAPE, SIZE, or UBOUND, or the function C_LOC from the intrinsic module ISO_C_BINDING. C711 An assumed-type actual argument that corresponds to an assumed-rank dummy argument shall be assumed-shape or assumed-rank. For C709 I added code to check-declarations.cpp. For this, I had to distinguish between polymorphic types and assumed-type types to eliminate multiple messages on the same line. C710 was already checked, but I added a notation in the source. For C711 I added code to check-call.cpp and the test call15.f90. Original-commit: flang-compiler/f18@4a703f2b5a6484208a059dc0b456363c138a661d Reviewed-on: https://github.com/flang-compiler/f18/pull/985
2020-02-15 07:53:11 +08:00
} else {
[flang] Revert recent addition of ActualArgument::PassedObject reformatting Complete merging with current master implement extension of inherited type-bound generics Original-commit: flang-compiler/f18@e58c4e53c2fcf6559e7254ce0fd1e4b96d158c73 Reviewed-on: https://github.com/flang-compiler/f18/pull/864
2019-12-10 05:52:12 +08:00
const Symbol &assumed{DEREF(arg.GetAssumedTypeDummy())};
[flang] Semantic checks for C709, C710, and C711 C709 An assumed-type entity shall be a dummy data object that does not have the ALLOCATABLE, CODIMENSION, INTENT (OUT), POINTER, or VALUE attribute and is not an explicit-shape array. C710 An assumed-type variable name shall not appear in a designator or expression except as an actual argument corresponding to a dummy argument that is assumed-type, or as the first argument to the intrinsic function IS_CONTIGUOUS, LBOUND, PRESENT, RANK, SHAPE, SIZE, or UBOUND, or the function C_LOC from the intrinsic module ISO_C_BINDING. C711 An assumed-type actual argument that corresponds to an assumed-rank dummy argument shall be assumed-shape or assumed-rank. For C709 I added code to check-declarations.cpp. For this, I had to distinguish between polymorphic types and assumed-type types to eliminate multiple messages on the same line. C710 was already checked, but I added a notation in the source. For C711 I added code to check-call.cpp and the test call15.f90. Original-commit: flang-compiler/f18@4a703f2b5a6484208a059dc0b456363c138a661d Reviewed-on: https://github.com/flang-compiler/f18/pull/985
2020-02-15 07:53:11 +08:00
if (!object.type.type().IsAssumedType()) {
messages.Say(
[flang] Use hash table for UnitMap, avoid C++ STL binary dependence Scan FORMAT strings locally to avoid C++ binary runtime dependence when computing deepest parenthesis nesting Remove a dependency on ostream from runtime Remove remaining direct external references from runtime to C++ library binaries Remove runtime dependences on lib/common SetPos() and SetRec() Instantiate templates for input Begin input; rearrange locking, deal with CLOSE races View() Update error message in test to agree with compiler change First cut at real input More robust I/O runtime error handling Debugging of REAL input Add iostat.{h,cpp} Rename runtime/numeric-* to runtime/edit-* Move templates around, templatize integer output editing Move LOGICAL and CHARACTER output from io-api.cpp to edit-output.cpp Change pointer argument to reference More list-directed input Complex list-directed input Use enum class Direction rather than bool for templates Catch up with changes to master Undo reformatting of Lower code Use record number instead of subscripts for internal unit Unformatted sequential backspace Testing and debugging Dodge bogus GCC warning Add <cstddef> for std::size_t to fix CI build Address review comments Original-commit: flang-compiler/f18@50406b349609efdde76e48bf2caa039d031dd1c4 Reviewed-on: https://github.com/flang-compiler/f18/pull/1053
2020-02-14 06:41:56 +08:00
"Assumed-type '%s' may be associated only with an assumed-type %s"_err_en_US,
[flang] Semantic checks for C709, C710, and C711 C709 An assumed-type entity shall be a dummy data object that does not have the ALLOCATABLE, CODIMENSION, INTENT (OUT), POINTER, or VALUE attribute and is not an explicit-shape array. C710 An assumed-type variable name shall not appear in a designator or expression except as an actual argument corresponding to a dummy argument that is assumed-type, or as the first argument to the intrinsic function IS_CONTIGUOUS, LBOUND, PRESENT, RANK, SHAPE, SIZE, or UBOUND, or the function C_LOC from the intrinsic module ISO_C_BINDING. C711 An assumed-type actual argument that corresponds to an assumed-rank dummy argument shall be assumed-shape or assumed-rank. For C709 I added code to check-declarations.cpp. For this, I had to distinguish between polymorphic types and assumed-type types to eliminate multiple messages on the same line. C710 was already checked, but I added a notation in the source. For C711 I added code to check-call.cpp and the test call15.f90. Original-commit: flang-compiler/f18@4a703f2b5a6484208a059dc0b456363c138a661d Reviewed-on: https://github.com/flang-compiler/f18/pull/985
2020-02-15 07:53:11 +08:00
assumed.name(), dummyName);
[flang] Check constraint C711 correctly An assumed-type actual argument that corresponds to an assumed-rank dummy argument shall be assumed-shape or assumed-rank. Differential Revision: https://reviews.llvm.org/D120750
2022-02-19 04:25:58 +08:00
} else if (object.type.attrs().test(evaluate::characteristics::
TypeAndShape::Attr::AssumedRank) &&
!IsAssumedShape(assumed) &&
!evaluate::IsAssumedRank(assumed)) {
messages.Say( // C711
"Assumed-type '%s' must be either assumed shape or assumed rank to be associated with assumed rank %s"_err_en_US,
assumed.name(), dummyName);
[flang] Semantic checks for C709, C710, and C711 C709 An assumed-type entity shall be a dummy data object that does not have the ALLOCATABLE, CODIMENSION, INTENT (OUT), POINTER, or VALUE attribute and is not an explicit-shape array. C710 An assumed-type variable name shall not appear in a designator or expression except as an actual argument corresponding to a dummy argument that is assumed-type, or as the first argument to the intrinsic function IS_CONTIGUOUS, LBOUND, PRESENT, RANK, SHAPE, SIZE, or UBOUND, or the function C_LOC from the intrinsic module ISO_C_BINDING. C711 An assumed-type actual argument that corresponds to an assumed-rank dummy argument shall be assumed-shape or assumed-rank. For C709 I added code to check-declarations.cpp. For this, I had to distinguish between polymorphic types and assumed-type types to eliminate multiple messages on the same line. C710 was already checked, but I added a notation in the source. For C711 I added code to check-call.cpp and the test call15.f90. Original-commit: flang-compiler/f18@4a703f2b5a6484208a059dc0b456363c138a661d Reviewed-on: https://github.com/flang-compiler/f18/pull/985
2020-02-15 07:53:11 +08:00
}
[flang] Fix some bugs exposed by testing new checks Original-commit: flang-compiler/f18@9cc70dcad64a77bb67cdb30f157a00898227f727 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 00:39:37 +08:00
}
},
[flang] Upgrade warning to error in case of PURE procedure A procedure actual argument to a PURE procedure should be required to have an explicit interface. Implicit-interface actual arguments to non-PURE procedures remain a warning. Differential Revision: https://reviews.llvm.org/D109926
2021-09-15 03:44:57 +08:00
[&](const characteristics::DummyProcedure &dummy) {
CheckProcedureArg(arg, proc, dummy, dummyName, context);
[flang] checkpoint, all tests pass Fix name resolution for undeclared intrinsic actual arguments Original-commit: flang-compiler/f18@12470f06bcc09eb4858af9c3e412752d7ba71aee Reviewed-on: https://github.com/flang-compiler/f18/pull/818
2019-11-08 08:01:38 +08:00
},
[&](const characteristics::AlternateReturn &) {
[flang] Fix bogus message on internal subprogram with alternate return Internal subprograms have explicit interfaces. If an internal subprogram has an alternate return, we check its explicit interface. But we were not putting the label values of alternate returns into the actual argument. I fixed this by changing the definition of actual arguments to be able to contain a common::Label and putting the label for an alternate return into the actual argument. I also verified that we were already doing all of the semantic checking required for alternate returns and removed a "TODO" for this. I also added the test altreturn06.f90. Differential Revision: https://reviews.llvm.org/D94017
2021-01-05 01:35:15 +08:00
// All semantic checking is done elsewhere
[flang] Fix some bugs exposed by testing new checks Original-commit: flang-compiler/f18@9cc70dcad64a77bb67cdb30f157a00898227f727 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 00:39:37 +08:00
},
},
dummy.u);
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
}
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
static void RearrangeArguments(const characteristics::Procedure &proc,
evaluate::ActualArguments &actuals, parser::ContextualMessages &messages) {
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
CHECK(proc.HasExplicitInterface());
if (actuals.size() < proc.dummyArguments.size()) {
actuals.resize(proc.dummyArguments.size());
} else if (actuals.size() > proc.dummyArguments.size()) {
messages.Say(
"Too many actual arguments (%zd) passed to procedure that expects only %zd"_err_en_US,
actuals.size(), proc.dummyArguments.size());
}
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
std::map<std::string, evaluate::ActualArgument> kwArgs;
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
for (auto &x : actuals) {
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
if (x && x->keyword()) {
auto emplaced{
kwArgs.try_emplace(x->keyword()->ToString(), std::move(*x))};
if (!emplaced.second) {
messages.Say(*x->keyword(),
"Argument keyword '%s=' appears on more than one effective argument in this procedure reference"_err_en_US,
*x->keyword());
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
}
[flang] C_F_POINTER Emit INTRINSIC statements in module files Argument checking utility Complete error checking Original-commit: flang-compiler/f18@9c6a88f0482c1f222b37e0cc548c822f80ad00e7 Reviewed-on: https://github.com/flang-compiler/f18/pull/896
2019-12-26 04:29:50 +08:00
x.reset();
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
}
}
if (!kwArgs.empty()) {
int index{0};
for (const auto &dummy : proc.dummyArguments) {
if (!dummy.name.empty()) {
auto iter{kwArgs.find(dummy.name)};
if (iter != kwArgs.end()) {
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
evaluate::ActualArgument &x{iter->second};
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (actuals[index]) {
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
messages.Say(*x.keyword(),
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
"Keyword argument '%s=' has already been specified positionally (#%d) in this procedure reference"_err_en_US,
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
*x.keyword(), index + 1);
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
} else {
actuals[index] = std::move(x);
}
kwArgs.erase(iter);
}
}
++index;
}
for (auto &bad : kwArgs) {
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
evaluate::ActualArgument &x{bad.second};
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
messages.Say(*x.keyword(),
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
"Argument keyword '%s=' is not recognized for this procedure reference"_err_en_US,
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
*x.keyword());
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
}
}
[flang] Generic name resolution in expression analysis Implement the basics of resolving generic names in expressions. `ExpressionAnalyzer::ResolveGeneric` maps the symbol for a generic name to the specific procedure appropriate for the actual arguments. Extract `CheckExplicitInterface` out of `CheckArguments` so that it can be tried for each specific procedure of the generic as part of the test to see which is compatible. Note that it may be there is an elemental and non-elemental specific procedure that is compatible with the actual arguments. In that case the generic is resolved to the non-elemental one. Test this by using generic functions in specification expressions that must be written to module files. Verify how the generics were resolved by looking at the generated `.mod` files. There is more work to be done in this area: the passed-object dummy argument is not considered and in some cases generated module files are not correct. Original-commit: flang-compiler/f18@50e458045a3de42bd60515956e09f0f2d654ae1e Reviewed-on: https://github.com/flang-compiler/f18/pull/778
2019-10-10 07:08:13 +08:00
}
[flang] Enforce array conformance in actual arguments to ELEMENTALs When the shapes of actual arguments to ELEMENTAL procedures are sufficiently well known during semantics, require them to conform. Differential Revision: https://reviews.llvm.org/D109909
2021-09-10 04:09:48 +08:00
// The actual argument arrays to an ELEMENTAL procedure must conform.
static bool CheckElementalConformance(parser::ContextualMessages &messages,
const characteristics::Procedure &proc, evaluate::ActualArguments &actuals,
evaluate::FoldingContext &context) {
std::optional<evaluate::Shape> shape;
std::string shapeName;
int index{0};
for (const auto &arg : actuals) {
const auto &dummy{proc.dummyArguments.at(index++)};
if (arg) {
if (const auto *expr{arg->UnwrapExpr()}) {
if (auto argShape{evaluate::GetShape(context, *expr)}) {
if (GetRank(*argShape) > 0) {
std::string argName{"actual argument ("s + expr->AsFortran() +
") corresponding to dummy argument #" + std::to_string(index) +
" ('" + dummy.name + "')"};
if (shape) {
auto tristate{evaluate::CheckConformance(messages, *shape,
*argShape, evaluate::CheckConformanceFlags::None,
shapeName.c_str(), argName.c_str())};
if (tristate && !*tristate) {
return false;
}
} else {
shape = std::move(argShape);
shapeName = argName;
}
}
}
}
}
}
return true;
}
[flang] Resolve defined operators to specifics Most of these changes involve moving code around so that it case be used for `DefinedUnary` and `DefinedBinary`. The functional changes are in the `Analyze` member functions for those cases where the arguments are now analyzed, the generic is resolved, and a `FunctionRef` is created. Add `ArgumentAnalyzer` to handling building of the `ActualArguments` of a call. This allows the code to be shared with the defined unary and defined binary cases. Move `AnalyzeActualArgument` and `AnalyzeActualArgument` into that class (renaming both to `Analyze`). Create an overload of `GetCalleeAndArguments` for the `Name` case so it can be used for defined ops where we don't have a `ProcedureDesignator`. Move `IsGenericDefinedOp` to `tools.h` to make it available to the new code. We were using `semantics::CheckExplicitInterface` to resolve a generic interface to a specific procedure based on actual arguments. The problem with that is that it performs too many checks. We just want to get the right specific; there may be errors reported later during call analysis. To fix this, add a new function, `CheckInterfaceForGeneric`, to perform this check. It shares code with `CheckExplicitInterface`, but it passes in a null scope to indicate that the full set of checks aren't necessary in `CheckExplicitInterfaceArg`. Instead we lift the call to `TypeAndShape::IsCompatibleWith` out of `CheckExplicitDataArg`, and skip the latter when there is no scope. Original-commit: flang-compiler/f18@fff2d1580f26719e0c384c66576aa6620d04faff Reviewed-on: https://github.com/flang-compiler/f18/pull/786
2019-10-23 00:31:33 +08:00
static parser::Messages CheckExplicitInterface(
const characteristics::Procedure &proc, evaluate::ActualArguments &actuals,
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
const evaluate::FoldingContext &context, const Scope *scope,
[flang] Fix generic resolution case Don't try to convert INTEGER argument expressions to the kind of the dummy argument when performing generic resolution; specific procedures may be distinguished only by their kinds. Differential Revision: https://reviews.llvm.org/D112240
2021-10-20 02:34:57 +08:00
const evaluate::SpecificIntrinsic *intrinsic,
bool allowIntegerConversions) {
[flang] rebase Original-commit: flang-compiler/f18@2691da38361cb4040e394dd5f631becf4caef221 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-12 06:41:11 +08:00
parser::Messages buffer;
parser::ContextualMessages messages{context.messages().at(), &buffer};
RearrangeArguments(proc, actuals, messages);
if (buffer.empty()) {
int index{0};
[flang] Fix problems with passed-object arguments by deferring the identification of their index in the dummy argument list, simplifying their representation, completing the representation of their actual arguments, and (while I'm here) resolving calls to type-bound procedures whose bindings are known at compilation time. Button up class ActualArgument by making remaining data members private and adding accessors & mutators. Original-commit: flang-compiler/f18@5eb60ec41912b0963e41bbc1a3141164efcb7fbf Reviewed-on: https://github.com/flang-compiler/f18/pull/855
2019-12-06 02:24:18 +08:00
evaluate::FoldingContext localContext{context, messages};
[flang] rebase Original-commit: flang-compiler/f18@2691da38361cb4040e394dd5f631becf4caef221 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-12 06:41:11 +08:00
for (auto &actual : actuals) {
const auto &dummy{proc.dummyArguments.at(index++)};
[flang] Remove most comparisons to nullptr Remove needless usage of has_value() Original-commit: flang-compiler/f18@1da7fcf7a54066b18e521620ecedb79c7cd2eb97 Reviewed-on: https://github.com/flang-compiler/f18/pull/822
2019-11-10 01:29:31 +08:00
if (actual) {
[flang] Fix generic resolution case Don't try to convert INTEGER argument expressions to the kind of the dummy argument when performing generic resolution; specific procedures may be distinguished only by their kinds. Differential Revision: https://reviews.llvm.org/D112240
2021-10-20 02:34:57 +08:00
CheckExplicitInterfaceArg(*actual, dummy, proc, localContext, scope,
intrinsic, allowIntegerConversions);
[flang] rebase Original-commit: flang-compiler/f18@2691da38361cb4040e394dd5f631becf4caef221 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-12 06:41:11 +08:00
} else if (!dummy.IsOptional()) {
if (dummy.name.empty()) {
messages.Say(
"Dummy argument #%d is not OPTIONAL and is not associated with "
"an actual argument in this procedure reference"_err_en_US,
index);
} else {
[flang] Revert to returning default INTEGER for LEN() and offset-in-CHARACTER intrinsics; further shape analysis of intrinsic results Original-commit: flang-compiler/f18@561f5965b2309df3cd15d7e2a96d7e73f2f76e35 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 02:53:03 +08:00
messages.Say("Dummy argument '%s=' (#%d) is not OPTIONAL and is not "
"associated with an actual argument in this procedure "
"reference"_err_en_US,
[flang] rebase Original-commit: flang-compiler/f18@2691da38361cb4040e394dd5f631becf4caef221 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-12 06:41:11 +08:00
dummy.name, index);
}
[flang] Generic name resolution in expression analysis Implement the basics of resolving generic names in expressions. `ExpressionAnalyzer::ResolveGeneric` maps the symbol for a generic name to the specific procedure appropriate for the actual arguments. Extract `CheckExplicitInterface` out of `CheckArguments` so that it can be tried for each specific procedure of the generic as part of the test to see which is compatible. Note that it may be there is an elemental and non-elemental specific procedure that is compatible with the actual arguments. In that case the generic is resolved to the non-elemental one. Test this by using generic functions in specification expressions that must be written to module files. Verify how the generics were resolved by looking at the generated `.mod` files. There is more work to be done in this area: the passed-object dummy argument is not considered and in some cases generated module files are not correct. Original-commit: flang-compiler/f18@50e458045a3de42bd60515956e09f0f2d654ae1e Reviewed-on: https://github.com/flang-compiler/f18/pull/778
2019-10-10 07:08:13 +08:00
}
}
[flang] Enforce array conformance in actual arguments to ELEMENTALs When the shapes of actual arguments to ELEMENTAL procedures are sufficiently well known during semantics, require them to conform. Differential Revision: https://reviews.llvm.org/D109909
2021-09-10 04:09:48 +08:00
if (proc.IsElemental() && !buffer.AnyFatalError()) {
CheckElementalConformance(messages, proc, actuals, localContext);
}
[flang] Generic name resolution in expression analysis Implement the basics of resolving generic names in expressions. `ExpressionAnalyzer::ResolveGeneric` maps the symbol for a generic name to the specific procedure appropriate for the actual arguments. Extract `CheckExplicitInterface` out of `CheckArguments` so that it can be tried for each specific procedure of the generic as part of the test to see which is compatible. Note that it may be there is an elemental and non-elemental specific procedure that is compatible with the actual arguments. In that case the generic is resolved to the non-elemental one. Test this by using generic functions in specification expressions that must be written to module files. Verify how the generics were resolved by looking at the generated `.mod` files. There is more work to be done in this area: the passed-object dummy argument is not considered and in some cases generated module files are not correct. Original-commit: flang-compiler/f18@50e458045a3de42bd60515956e09f0f2d654ae1e Reviewed-on: https://github.com/flang-compiler/f18/pull/778
2019-10-10 07:08:13 +08:00
}
[flang] rebase Original-commit: flang-compiler/f18@2691da38361cb4040e394dd5f631becf4caef221 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-12 06:41:11 +08:00
return buffer;
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
}
[flang] Resolve defined operators to specifics Most of these changes involve moving code around so that it case be used for `DefinedUnary` and `DefinedBinary`. The functional changes are in the `Analyze` member functions for those cases where the arguments are now analyzed, the generic is resolved, and a `FunctionRef` is created. Add `ArgumentAnalyzer` to handling building of the `ActualArguments` of a call. This allows the code to be shared with the defined unary and defined binary cases. Move `AnalyzeActualArgument` and `AnalyzeActualArgument` into that class (renaming both to `Analyze`). Create an overload of `GetCalleeAndArguments` for the `Name` case so it can be used for defined ops where we don't have a `ProcedureDesignator`. Move `IsGenericDefinedOp` to `tools.h` to make it available to the new code. We were using `semantics::CheckExplicitInterface` to resolve a generic interface to a specific procedure based on actual arguments. The problem with that is that it performs too many checks. We just want to get the right specific; there may be errors reported later during call analysis. To fix this, add a new function, `CheckInterfaceForGeneric`, to perform this check. It shares code with `CheckExplicitInterface`, but it passes in a null scope to indicate that the full set of checks aren't necessary in `CheckExplicitInterfaceArg`. Instead we lift the call to `TypeAndShape::IsCompatibleWith` out of `CheckExplicitDataArg`, and skip the latter when there is no scope. Original-commit: flang-compiler/f18@fff2d1580f26719e0c384c66576aa6620d04faff Reviewed-on: https://github.com/flang-compiler/f18/pull/786
2019-10-23 00:31:33 +08:00
parser::Messages CheckExplicitInterface(const characteristics::Procedure &proc,
evaluate::ActualArguments &actuals, const evaluate::FoldingContext &context,
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
const Scope &scope, const evaluate::SpecificIntrinsic *intrinsic) {
[flang] Fix generic resolution case Don't try to convert INTEGER argument expressions to the kind of the dummy argument when performing generic resolution; specific procedures may be distinguished only by their kinds. Differential Revision: https://reviews.llvm.org/D112240
2021-10-20 02:34:57 +08:00
return CheckExplicitInterface(
proc, actuals, context, &scope, intrinsic, true);
[flang] Resolve defined operators to specifics Most of these changes involve moving code around so that it case be used for `DefinedUnary` and `DefinedBinary`. The functional changes are in the `Analyze` member functions for those cases where the arguments are now analyzed, the generic is resolved, and a `FunctionRef` is created. Add `ArgumentAnalyzer` to handling building of the `ActualArguments` of a call. This allows the code to be shared with the defined unary and defined binary cases. Move `AnalyzeActualArgument` and `AnalyzeActualArgument` into that class (renaming both to `Analyze`). Create an overload of `GetCalleeAndArguments` for the `Name` case so it can be used for defined ops where we don't have a `ProcedureDesignator`. Move `IsGenericDefinedOp` to `tools.h` to make it available to the new code. We were using `semantics::CheckExplicitInterface` to resolve a generic interface to a specific procedure based on actual arguments. The problem with that is that it performs too many checks. We just want to get the right specific; there may be errors reported later during call analysis. To fix this, add a new function, `CheckInterfaceForGeneric`, to perform this check. It shares code with `CheckExplicitInterface`, but it passes in a null scope to indicate that the full set of checks aren't necessary in `CheckExplicitInterfaceArg`. Instead we lift the call to `TypeAndShape::IsCompatibleWith` out of `CheckExplicitDataArg`, and skip the latter when there is no scope. Original-commit: flang-compiler/f18@fff2d1580f26719e0c384c66576aa6620d04faff Reviewed-on: https://github.com/flang-compiler/f18/pull/786
2019-10-23 00:31:33 +08:00
}
bool CheckInterfaceForGeneric(const characteristics::Procedure &proc,
[flang] Fix generic resolution case Don't try to convert INTEGER argument expressions to the kind of the dummy argument when performing generic resolution; specific procedures may be distinguished only by their kinds. Differential Revision: https://reviews.llvm.org/D112240
2021-10-20 02:34:57 +08:00
evaluate::ActualArguments &actuals, const evaluate::FoldingContext &context,
bool allowIntegerConversions) {
return !CheckExplicitInterface(
proc, actuals, context, nullptr, nullptr, allowIntegerConversions)
[flang] More precise checks for NULL() operands Improve checking for NULL() and NULL(MOLD=) when used as variables and expressions outside the few contexts where a disassociated pointer can be valid. There were both inappropriate errors and missing checks. Differential Revision: https://reviews.llvm.org/D109905
2021-09-08 03:17:31 +08:00
.AnyFatalError();
[flang] Resolve defined operators to specifics Most of these changes involve moving code around so that it case be used for `DefinedUnary` and `DefinedBinary`. The functional changes are in the `Analyze` member functions for those cases where the arguments are now analyzed, the generic is resolved, and a `FunctionRef` is created. Add `ArgumentAnalyzer` to handling building of the `ActualArguments` of a call. This allows the code to be shared with the defined unary and defined binary cases. Move `AnalyzeActualArgument` and `AnalyzeActualArgument` into that class (renaming both to `Analyze`). Create an overload of `GetCalleeAndArguments` for the `Name` case so it can be used for defined ops where we don't have a `ProcedureDesignator`. Move `IsGenericDefinedOp` to `tools.h` to make it available to the new code. We were using `semantics::CheckExplicitInterface` to resolve a generic interface to a specific procedure based on actual arguments. The problem with that is that it performs too many checks. We just want to get the right specific; there may be errors reported later during call analysis. To fix this, add a new function, `CheckInterfaceForGeneric`, to perform this check. It shares code with `CheckExplicitInterface`, but it passes in a null scope to indicate that the full set of checks aren't necessary in `CheckExplicitInterfaceArg`. Instead we lift the call to `TypeAndShape::IsCompatibleWith` out of `CheckExplicitDataArg`, and skip the latter when there is no scope. Original-commit: flang-compiler/f18@fff2d1580f26719e0c384c66576aa6620d04faff Reviewed-on: https://github.com/flang-compiler/f18/pull/786
2019-10-23 00:31:33 +08:00
}
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
void CheckArguments(const characteristics::Procedure &proc,
[flang] Move call semantic checking into lib/semantics Original-commit: flang-compiler/f18@7996c85cf3311506093a9864263e198e4199ea29 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-10 07:30:34 +08:00
evaluate::ActualArguments &actuals, evaluate::FoldingContext &context,
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
const Scope &scope, bool treatingExternalAsImplicit,
const evaluate::SpecificIntrinsic *intrinsic) {
[flang] definability tests Original-commit: flang-compiler/f18@4b71f003a9c3a88b4a3e5cbad12f33fb46ef0657 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-11 04:09:35 +08:00
bool explicitInterface{proc.HasExplicitInterface()};
[flang] Accept BOZ literals for some actual arguments Consistent with previously documented policy, in which BOZ literals are accepted in non-standard-conforming circumstances where they can be converted to an unambiguous known numeric type, allow BOZ literals to be passed as an actual argument in a reference to a procedure whose explicit interface has a corresponding dummy argument with a numeric type to which the BOZ literal may be converted. Improve error messages associated with BOZ literal actual arguments, too: don't emit multiple errors. Differential Revision: https://reviews.llvm.org/D117698
2022-01-12 02:38:26 +08:00
parser::ContextualMessages &messages{context.messages()};
if (!explicitInterface || treatingExternalAsImplicit) {
parser::Messages buffer;
{
auto restorer{messages.SetMessages(buffer)};
for (auto &actual : actuals) {
if (actual) {
CheckImplicitInterfaceArg(*actual, messages);
}
}
}
if (!buffer.empty()) {
if (auto *msgs{messages.messages()}) {
msgs->Annex(std::move(buffer));
}
return; // don't pile on
}
}
[flang] rebase Original-commit: flang-compiler/f18@2691da38361cb4040e394dd5f631becf4caef221 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-12 06:41:11 +08:00
if (explicitInterface) {
[flang] Document and use intrinsic subroutine argument intents Check INTENT(OUT)/INTENT(INOUT) constraints for actual argument of intrinsic procedure calls. - Adding a common::Intent field to the IntrinsicDummyArgument in the intrinsic table. - Propagating it to the DummyDataObject intent field so that it can later be used in CheckExplicitDataArg semantic checks. - Add related tests. - Fix regression (C846 false error), C846 INTENT(OUT) rule does not apply to intrinsic call. Propagate the information that we are in an intrinsic call up to CheckExplicitDataArg (that is doing this check). Still enforce C846 on intrinsics other than MOVE_ALLOC (for which allocatable coarrays are explicitly allowed) since it's not clear it is allowed in all intrinsics and allowing this would lead to runtime penalties in the intrinsic runtime. Differential Revision: https://reviews.llvm.org/D89473
2020-10-20 18:39:26 +08:00
auto buffer{
CheckExplicitInterface(proc, actuals, context, scope, intrinsic)};
[flang] Fix some bugs exposed by testing new checks Original-commit: flang-compiler/f18@9cc70dcad64a77bb67cdb30f157a00898227f727 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 00:39:37 +08:00
if (treatingExternalAsImplicit && !buffer.empty()) {
[flang] Accept BOZ literals for some actual arguments Consistent with previously documented policy, in which BOZ literals are accepted in non-standard-conforming circumstances where they can be converted to an unambiguous known numeric type, allow BOZ literals to be passed as an actual argument in a reference to a procedure whose explicit interface has a corresponding dummy argument with a numeric type to which the BOZ literal may be converted. Improve error messages associated with BOZ literal actual arguments, too: don't emit multiple errors. Differential Revision: https://reviews.llvm.org/D117698
2022-01-12 02:38:26 +08:00
if (auto *msg{messages.Say(
[flang] Distinguish usage and portability warning messages Using recently established message severity codes, upgrade non-fatal messages to usage and portability warnings as appropriate. Differential Revision: https://reviews.llvm.org/D121246
2022-03-08 05:57:37 +08:00
"If the procedure's interface were explicit, this reference would be in error:"_warn_en_US)}) {
[flang] Improve appearance of message attachments Error messages can have a list of attachments; these are used to point to related source locations, supply additional information, and to encapsulate error messages that were *not* emitted in a given context to explain why a warning was justified. This patch adds a message severity ("Because") for that last case, and extends to AttachTo() API to provide a means for overriding the severity of an attached message. Some existing message attachments had their severities adjusted, now that we're printing them. And operator==() for Message was cleaned up while debugging after I noticed that it was recursively O(N**2) and subject to returning a false positive. Differential Revision: https://reviews.llvm.org/D123710
2022-04-02 03:46:04 +08:00
buffer.AttachTo(*msg, parser::Severity::Because);
[flang] Fix some bugs exposed by testing new checks Original-commit: flang-compiler/f18@9cc70dcad64a77bb67cdb30f157a00898227f727 Reviewed-on: https://github.com/flang-compiler/f18/pull/782 Tree-same-pre-rewrite: false
2019-10-17 00:39:37 +08:00
}
}
[flang] Accept BOZ literals for some actual arguments Consistent with previously documented policy, in which BOZ literals are accepted in non-standard-conforming circumstances where they can be converted to an unambiguous known numeric type, allow BOZ literals to be passed as an actual argument in a reference to a procedure whose explicit interface has a corresponding dummy argument with a numeric type to which the BOZ literal may be converted. Improve error messages associated with BOZ literal actual arguments, too: don't emit multiple errors. Differential Revision: https://reviews.llvm.org/D117698
2022-01-12 02:38:26 +08:00
if (auto *msgs{messages.messages()}) {
msgs->Annex(std::move(buffer));
[flang] Update preprocessing document, commentary Extend documentation on preprocessing IsSimplyContiguous basic skeleton Apply suggested improvements to mod-file.cc Checks for new call13.f90 (15.4.2.2 explicit interfaces) Implement checking for procedures that can be called via an implicit interface Argument checking, test fixing Better argument checking Better derived type compatibility checking Treat externals as if implicitly interfaced Extend IEEE_EXCEPTIONS module so tests still pass with argument checking SAME_TYPE_AS and EXTENDS_TYPE_OF intrinsic inquiry functions Define interfaces for most intrinsic subroutines Better PASS arguments More with PASS() argument Prep for review address comments fix comment Remove formatted expression from specification expression error message per review more review comments Original-commit: flang-compiler/f18@3cca775da9302e3a2acec4a34800cd7666899b5f Reviewed-on: https://github.com/flang-compiler/f18/pull/776
2019-09-17 07:58:13 +08:00
}
}
}
[flang] Reformat with latest clang-format and .clang-format Original-commit: flang-compiler/f18@9fe84f45d7fd685051004678d6b5775dcc4c6f8f Reviewed-on: https://github.com/flang-compiler/f18/pull/1094
2020-03-29 12:00:16 +08:00
} // namespace Fortran::semantics