maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/flang/test/Semantics/modfile12.f90

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

67 lines
1.3 KiB
Fortran
Raw Normal View History

[flang][NFC] Simplify semantics test scripts There were several different ways of handling the option to f18 to find predefined modules: - test_errors.sh was created by cmake substituting FLANG_INTRINSIC_MODULES_DIR into test_errors.sh.in - some tests used the flang script which has the option built it - some tests used %f18_with_includes which was replaced by the path to f18 plus the -I option - some included -I../../include/flang in their run command To make this more consistent, change %f18 to include the -intrinsic-module-directory option and use it everywhere, including to replace %flang and %f18_with_includes. This requires changing all of the invocations of the test scripts to put %f18 at the end so that it can expand to more than one argument. This eliminates the need to generate test_errors.sh which means we don't need flang/test/Semantics/CMakeLists.txt or the %B substitution. That makes the test_errors.sh command like the others, replacing %B/test/Semantics/test_errors.sh with %S/test_errors.sh. Also remove the OPTIONS: functionality as custom options can be included in the RUN: command. And remove -I/../../include/flang as that is now always included. Differential Revision: https://reviews.llvm.org/D79634
2020-05-12 02:38:53 +08:00
! RUN: %S/test_modfile.sh %s %t %f18
[flang] Resolve expressions in symbols Add `LazyExpr` class to represent expressions in the symbol table. Initially they contain a pointer to an expression in the parse tree. After name resolution is complete and symbols are filled in in the parse tree, `LazyExpr`s are resolved to `evaluate::Expr<evaluate::SomeType>`. This is done by `ResolveSymbolExprs()`. Change `Bound` and `ParamValue` to save their value as a `LazyExpr`. Change `ObjectEntityDetails` and `TypeParamDetails` to save the initial value as a `LazyExpr`. Eliminate `IntExpr` and `IntConst` classes, which were just place-holders. Add `Clone()` to `ShapeSpec`, `Bound`, `LazyExpr`. Normally they should be moved but in `ObjectEntityDetails::set_shape()` we need to make copies. Save type parameter values in `derivedTypeSpec_`. `typeParamValue_` is not needed. Write out initial values, type parameter values, and bounds to .mod files. Evaluate parameter values in expressions. Make some errors non-fatal so that tests can continue to pass. Original-commit: flang-compiler/f18@b90cadfc53c6e31c5f289eadc382bc3908811b86 Reviewed-on: https://github.com/flang-compiler/f18/pull/223 Tree-same-pre-rewrite: false
2018-11-07 09:18:06 +08:00
module m
integer(8), parameter :: a = 1, b = 2_8
[flang] Rework when symbol table expressions are evaluated It's not good enough to evaluate expressions in the symbol table after name resolution has completed. This is because we need the values of constant expressions for types, for example, we need to evaluate `k` in `integer(k) :: x` to know the type of `x`. So, eliminate `LazyExpr` and call `EvaluateExpr()` on expressions that we need in the symbol table. The latter evaluates and folds an expression in the current context. This is now possible because symbols are added to `parser::Name` as soon as possible rather than in a pass after name resolution. Along with `LazyExpr` we can eliminate the whole `ResolveSymbolExprs` pass that used to resolve them. In resolve-names.cc, many `Pre` functions are changed to `Post` so that names are resolved before doing the associated processing. For example, with intrinsic type specs, names in the kind expression must be resolved before attempting to evaluate that expression. In `GetSymbolType()` in type.cc, handle both `ObjectEntityDetails` and `EntityDetails` by using `Symbol::GetType()`. Add explicit declarations in label01.F90 because we can't handle implicitly typed array bounds yet. Original-commit: flang-compiler/f18@d67716640baeedca150205f9f3845ceb5d2f6402 Reviewed-on: https://github.com/flang-compiler/f18/pull/238
2018-12-06 22:59:37 +08:00
parameter(n=3,l=-3,e=1.0/3.0)
[flang] Resolve expressions in symbols Add `LazyExpr` class to represent expressions in the symbol table. Initially they contain a pointer to an expression in the parse tree. After name resolution is complete and symbols are filled in in the parse tree, `LazyExpr`s are resolved to `evaluate::Expr<evaluate::SomeType>`. This is done by `ResolveSymbolExprs()`. Change `Bound` and `ParamValue` to save their value as a `LazyExpr`. Change `ObjectEntityDetails` and `TypeParamDetails` to save the initial value as a `LazyExpr`. Eliminate `IntExpr` and `IntConst` classes, which were just place-holders. Add `Clone()` to `ShapeSpec`, `Bound`, `LazyExpr`. Normally they should be moved but in `ObjectEntityDetails::set_shape()` we need to make copies. Save type parameter values in `derivedTypeSpec_`. `typeParamValue_` is not needed. Write out initial values, type parameter values, and bounds to .mod files. Evaluate parameter values in expressions. Make some errors non-fatal so that tests can continue to pass. Original-commit: flang-compiler/f18@b90cadfc53c6e31c5f289eadc382bc3908811b86 Reviewed-on: https://github.com/flang-compiler/f18/pull/223 Tree-same-pre-rewrite: false
2018-11-07 09:18:06 +08:00
real :: x(a:2*(a+b*n)-1)
real, dimension(8) :: y
type t(c, d)
integer, kind :: c = 1
integer, len :: d = a + b
end type
[flang] Rework when symbol table expressions are evaluated It's not good enough to evaluate expressions in the symbol table after name resolution has completed. This is because we need the values of constant expressions for types, for example, we need to evaluate `k` in `integer(k) :: x` to know the type of `x`. So, eliminate `LazyExpr` and call `EvaluateExpr()` on expressions that we need in the symbol table. The latter evaluates and folds an expression in the current context. This is now possible because symbols are added to `parser::Name` as soon as possible rather than in a pass after name resolution. Along with `LazyExpr` we can eliminate the whole `ResolveSymbolExprs` pass that used to resolve them. In resolve-names.cc, many `Pre` functions are changed to `Post` so that names are resolved before doing the associated processing. For example, with intrinsic type specs, names in the kind expression must be resolved before attempting to evaluate that expression. In `GetSymbolType()` in type.cc, handle both `ObjectEntityDetails` and `EntityDetails` by using `Symbol::GetType()`. Add explicit declarations in label01.F90 because we can't handle implicitly typed array bounds yet. Original-commit: flang-compiler/f18@d67716640baeedca150205f9f3845ceb5d2f6402 Reviewed-on: https://github.com/flang-compiler/f18/pull/238
2018-12-06 22:59:37 +08:00
type(t(a+3,:)), allocatable :: z
[flang] Rework how DeclTypeSpecs are stored Now DeclTypeSpecs are stored in the scope so that they remain available as long as the scope exists. DeclTypeSpecs for intrinsic types are stored in the global scope; those for derived types are in the current scope. They can contains type parameter values so they can't be reused. Add `Semantics::MakeIntrinsicTypeSpec` to simplify creating DeclTypeSpecs for intrinsic types. Replace `std::optional<DeclTypeSpec>` with `DeclTypeSpec *` as they do not need to be copied around. Also fix a small bug with writing `class(t(...))` to the module file -- the type parameters were missing. Original-commit: flang-compiler/f18@e4744418fc1cdc9728bba4b9ecde51cb5bdd2efa Reviewed-on: https://github.com/flang-compiler/f18/pull/247 Tree-same-pre-rewrite: false
2018-12-12 06:51:08 +08:00
class(t(a+4,:)), allocatable :: z2
class(*), allocatable :: z4
[flang] Rework when symbol table expressions are evaluated It's not good enough to evaluate expressions in the symbol table after name resolution has completed. This is because we need the values of constant expressions for types, for example, we need to evaluate `k` in `integer(k) :: x` to know the type of `x`. So, eliminate `LazyExpr` and call `EvaluateExpr()` on expressions that we need in the symbol table. The latter evaluates and folds an expression in the current context. This is now possible because symbols are added to `parser::Name` as soon as possible rather than in a pass after name resolution. Along with `LazyExpr` we can eliminate the whole `ResolveSymbolExprs` pass that used to resolve them. In resolve-names.cc, many `Pre` functions are changed to `Post` so that names are resolved before doing the associated processing. For example, with intrinsic type specs, names in the kind expression must be resolved before attempting to evaluate that expression. In `GetSymbolType()` in type.cc, handle both `ObjectEntityDetails` and `EntityDetails` by using `Symbol::GetType()`. Add explicit declarations in label01.F90 because we can't handle implicitly typed array bounds yet. Original-commit: flang-compiler/f18@d67716640baeedca150205f9f3845ceb5d2f6402 Reviewed-on: https://github.com/flang-compiler/f18/pull/238
2018-12-06 22:59:37 +08:00
real*2 :: f
complex*32 :: g
[flang] Preserve order of type parameters Type parameters were sorted by the order of the type-param-def-stmts. But we need to preserve the order of the type-param-name-list. The is the order of positional parameters in a derived-type-spec. So add `paramNames` to `DerivedTypeDetails` to preserve the original order. Using this allows us to write module files with both the type-param-name-list and type-param-def-stmts in the original order. Also fix a bug where a duplicate type-param-def caused a spurious extra error. If `MakeTypeSymbol()` reports an error we should not call `SetType()` because it will just report another error. Original-commit: flang-compiler/f18@3ca55b63333db3d779fe263583e3cb9fe7f4b2b1 Reviewed-on: https://github.com/flang-compiler/f18/pull/239
2018-12-07 09:52:43 +08:00
type t2(i, j, h)
integer, len :: h
integer, kind :: j
integer, len :: i
end type
[flang] Resolve expressions in symbols Add `LazyExpr` class to represent expressions in the symbol table. Initially they contain a pointer to an expression in the parse tree. After name resolution is complete and symbols are filled in in the parse tree, `LazyExpr`s are resolved to `evaluate::Expr<evaluate::SomeType>`. This is done by `ResolveSymbolExprs()`. Change `Bound` and `ParamValue` to save their value as a `LazyExpr`. Change `ObjectEntityDetails` and `TypeParamDetails` to save the initial value as a `LazyExpr`. Eliminate `IntExpr` and `IntConst` classes, which were just place-holders. Add `Clone()` to `ShapeSpec`, `Bound`, `LazyExpr`. Normally they should be moved but in `ObjectEntityDetails::set_shape()` we need to make copies. Save type parameter values in `derivedTypeSpec_`. `typeParamValue_` is not needed. Write out initial values, type parameter values, and bounds to .mod files. Evaluate parameter values in expressions. Make some errors non-fatal so that tests can continue to pass. Original-commit: flang-compiler/f18@b90cadfc53c6e31c5f289eadc382bc3908811b86 Reviewed-on: https://github.com/flang-compiler/f18/pull/223 Tree-same-pre-rewrite: false
2018-11-07 09:18:06 +08:00
contains
subroutine foo(x)
real :: x(2:)
end
subroutine bar(x)
real :: x(..)
end
[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
subroutine baz(x)
type(*) :: x
end
[flang] Resolve expressions in symbols Add `LazyExpr` class to represent expressions in the symbol table. Initially they contain a pointer to an expression in the parse tree. After name resolution is complete and symbols are filled in in the parse tree, `LazyExpr`s are resolved to `evaluate::Expr<evaluate::SomeType>`. This is done by `ResolveSymbolExprs()`. Change `Bound` and `ParamValue` to save their value as a `LazyExpr`. Change `ObjectEntityDetails` and `TypeParamDetails` to save the initial value as a `LazyExpr`. Eliminate `IntExpr` and `IntConst` classes, which were just place-holders. Add `Clone()` to `ShapeSpec`, `Bound`, `LazyExpr`. Normally they should be moved but in `ObjectEntityDetails::set_shape()` we need to make copies. Save type parameter values in `derivedTypeSpec_`. `typeParamValue_` is not needed. Write out initial values, type parameter values, and bounds to .mod files. Evaluate parameter values in expressions. Make some errors non-fatal so that tests can continue to pass. Original-commit: flang-compiler/f18@b90cadfc53c6e31c5f289eadc382bc3908811b86 Reviewed-on: https://github.com/flang-compiler/f18/pull/223 Tree-same-pre-rewrite: false
2018-11-07 09:18:06 +08:00
end
!Expect: m.mod
!module m
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
! integer(8),parameter::a=1_8
[flang] Resolve expressions in symbols Add `LazyExpr` class to represent expressions in the symbol table. Initially they contain a pointer to an expression in the parse tree. After name resolution is complete and symbols are filled in in the parse tree, `LazyExpr`s are resolved to `evaluate::Expr<evaluate::SomeType>`. This is done by `ResolveSymbolExprs()`. Change `Bound` and `ParamValue` to save their value as a `LazyExpr`. Change `ObjectEntityDetails` and `TypeParamDetails` to save the initial value as a `LazyExpr`. Eliminate `IntExpr` and `IntConst` classes, which were just place-holders. Add `Clone()` to `ShapeSpec`, `Bound`, `LazyExpr`. Normally they should be moved but in `ObjectEntityDetails::set_shape()` we need to make copies. Save type parameter values in `derivedTypeSpec_`. `typeParamValue_` is not needed. Write out initial values, type parameter values, and bounds to .mod files. Evaluate parameter values in expressions. Make some errors non-fatal so that tests can continue to pass. Original-commit: flang-compiler/f18@b90cadfc53c6e31c5f289eadc382bc3908811b86 Reviewed-on: https://github.com/flang-compiler/f18/pull/223 Tree-same-pre-rewrite: false
2018-11-07 09:18:06 +08:00
! integer(8),parameter::b=2_8
! integer(4),parameter::n=3_4
[flang] Rework when symbol table expressions are evaluated It's not good enough to evaluate expressions in the symbol table after name resolution has completed. This is because we need the values of constant expressions for types, for example, we need to evaluate `k` in `integer(k) :: x` to know the type of `x`. So, eliminate `LazyExpr` and call `EvaluateExpr()` on expressions that we need in the symbol table. The latter evaluates and folds an expression in the current context. This is now possible because symbols are added to `parser::Name` as soon as possible rather than in a pass after name resolution. Along with `LazyExpr` we can eliminate the whole `ResolveSymbolExprs` pass that used to resolve them. In resolve-names.cc, many `Pre` functions are changed to `Post` so that names are resolved before doing the associated processing. For example, with intrinsic type specs, names in the kind expression must be resolved before attempting to evaluate that expression. In `GetSymbolType()` in type.cc, handle both `ObjectEntityDetails` and `EntityDetails` by using `Symbol::GetType()`. Add explicit declarations in label01.F90 because we can't handle implicitly typed array bounds yet. Original-commit: flang-compiler/f18@d67716640baeedca150205f9f3845ceb5d2f6402 Reviewed-on: https://github.com/flang-compiler/f18/pull/238
2018-12-06 22:59:37 +08:00
! integer(4),parameter::l=-3_4
! real(4),parameter::e=3.333333432674407958984375e-1_4
[flang] fold analyzed bounds expressions Original-commit: flang-compiler/f18@17810319ae0236045c510c2c25d23a6fc32956ff Reviewed-on: https://github.com/flang-compiler/f18/pull/253
2019-01-08 08:31:59 +08:00
! real(4)::x(1_8:13_8)
! real(4)::y(1_8:8_8)
[flang] Resolve expressions in symbols Add `LazyExpr` class to represent expressions in the symbol table. Initially they contain a pointer to an expression in the parse tree. After name resolution is complete and symbols are filled in in the parse tree, `LazyExpr`s are resolved to `evaluate::Expr<evaluate::SomeType>`. This is done by `ResolveSymbolExprs()`. Change `Bound` and `ParamValue` to save their value as a `LazyExpr`. Change `ObjectEntityDetails` and `TypeParamDetails` to save the initial value as a `LazyExpr`. Eliminate `IntExpr` and `IntConst` classes, which were just place-holders. Add `Clone()` to `ShapeSpec`, `Bound`, `LazyExpr`. Normally they should be moved but in `ObjectEntityDetails::set_shape()` we need to make copies. Save type parameter values in `derivedTypeSpec_`. `typeParamValue_` is not needed. Write out initial values, type parameter values, and bounds to .mod files. Evaluate parameter values in expressions. Make some errors non-fatal so that tests can continue to pass. Original-commit: flang-compiler/f18@b90cadfc53c6e31c5f289eadc382bc3908811b86 Reviewed-on: https://github.com/flang-compiler/f18/pull/223 Tree-same-pre-rewrite: false
2018-11-07 09:18:06 +08:00
! type::t(c,d)
! integer(4),kind::c=1_4
[flang] work in progress checkpoint: changes build, tests all pass many fixes, ready to test more Further CLASS(*) support More fixes for CLASS(*) Hide data members of DynamicType implement PRESENT() intrinsic Original-commit: flang-compiler/f18@044ba12c20f77c130e3c468914ddc2d6c8652c6e Reviewed-on: https://github.com/flang-compiler/f18/pull/466 Tree-same-pre-rewrite: false
2019-05-14 00:33:18 +08:00
! integer(4),len::d=3_4
[flang] Resolve expressions in symbols Add `LazyExpr` class to represent expressions in the symbol table. Initially they contain a pointer to an expression in the parse tree. After name resolution is complete and symbols are filled in in the parse tree, `LazyExpr`s are resolved to `evaluate::Expr<evaluate::SomeType>`. This is done by `ResolveSymbolExprs()`. Change `Bound` and `ParamValue` to save their value as a `LazyExpr`. Change `ObjectEntityDetails` and `TypeParamDetails` to save the initial value as a `LazyExpr`. Eliminate `IntExpr` and `IntConst` classes, which were just place-holders. Add `Clone()` to `ShapeSpec`, `Bound`, `LazyExpr`. Normally they should be moved but in `ObjectEntityDetails::set_shape()` we need to make copies. Save type parameter values in `derivedTypeSpec_`. `typeParamValue_` is not needed. Write out initial values, type parameter values, and bounds to .mod files. Evaluate parameter values in expressions. Make some errors non-fatal so that tests can continue to pass. Original-commit: flang-compiler/f18@b90cadfc53c6e31c5f289eadc382bc3908811b86 Reviewed-on: https://github.com/flang-compiler/f18/pull/223 Tree-same-pre-rewrite: false
2018-11-07 09:18:06 +08:00
! end type
[flang] basic skeleton of assignment analyzer remove needless template<> on some function overloads dodge bogus compiler warning from gcc 8.1.0 only stricter typing of expressions in symbols adjust modfile12.f90 expected test results add Unwrap, massage folding a bit Use Unwrap to simplify folding Move KindSelector analysis into expression semantics fix crash checkpoint updates to TypeParamInquiry support of %KIND type parameter inquiry equality testing for expressions checkpoint during PDT implementation reformat checkpoint derived type instantiation checkpoint resolve merge debugging failed tests fix failing resolve37.f90 test all existing tests pass clean up all build warnings fix bug update copyright dates fix copyright dates address review comments review comment merge with master after peeling off changes bugfixing new feature fix warning from old g++s tweaks after merging with latest head more bugfixing making modfile17.f90 test work Make kinds into expressions in symbol table types big refactor for deferring kinds in intrinsic types modfile17.f90 test passes clean up TODOs Simplify types as stored in scopes Test KIND parameter default init expressions, debug them Update copyright dates address comments remove dead line address comments Original-commit: flang-compiler/f18@1f43d0a04813dc02909e9952ee479d13f630df4c Reviewed-on: https://github.com/flang-compiler/f18/pull/260 Tree-same-pre-rewrite: false
2018-12-05 02:55:32 +08:00
! type(t(c=4_4,d=:)),allocatable::z
! class(t(c=5_4,d=:)),allocatable::z2
[flang] Rework how DeclTypeSpecs are stored Now DeclTypeSpecs are stored in the scope so that they remain available as long as the scope exists. DeclTypeSpecs for intrinsic types are stored in the global scope; those for derived types are in the current scope. They can contains type parameter values so they can't be reused. Add `Semantics::MakeIntrinsicTypeSpec` to simplify creating DeclTypeSpecs for intrinsic types. Replace `std::optional<DeclTypeSpec>` with `DeclTypeSpec *` as they do not need to be copied around. Also fix a small bug with writing `class(t(...))` to the module file -- the type parameters were missing. Original-commit: flang-compiler/f18@e4744418fc1cdc9728bba4b9ecde51cb5bdd2efa Reviewed-on: https://github.com/flang-compiler/f18/pull/247 Tree-same-pre-rewrite: false
2018-12-12 06:51:08 +08:00
! class(*),allocatable::z4
[flang] Rework when symbol table expressions are evaluated It's not good enough to evaluate expressions in the symbol table after name resolution has completed. This is because we need the values of constant expressions for types, for example, we need to evaluate `k` in `integer(k) :: x` to know the type of `x`. So, eliminate `LazyExpr` and call `EvaluateExpr()` on expressions that we need in the symbol table. The latter evaluates and folds an expression in the current context. This is now possible because symbols are added to `parser::Name` as soon as possible rather than in a pass after name resolution. Along with `LazyExpr` we can eliminate the whole `ResolveSymbolExprs` pass that used to resolve them. In resolve-names.cc, many `Pre` functions are changed to `Post` so that names are resolved before doing the associated processing. For example, with intrinsic type specs, names in the kind expression must be resolved before attempting to evaluate that expression. In `GetSymbolType()` in type.cc, handle both `ObjectEntityDetails` and `EntityDetails` by using `Symbol::GetType()`. Add explicit declarations in label01.F90 because we can't handle implicitly typed array bounds yet. Original-commit: flang-compiler/f18@d67716640baeedca150205f9f3845ceb5d2f6402 Reviewed-on: https://github.com/flang-compiler/f18/pull/238
2018-12-06 22:59:37 +08:00
! real(2)::f
! complex(16)::g
[flang] Preserve order of type parameters Type parameters were sorted by the order of the type-param-def-stmts. But we need to preserve the order of the type-param-name-list. The is the order of positional parameters in a derived-type-spec. So add `paramNames` to `DerivedTypeDetails` to preserve the original order. Using this allows us to write module files with both the type-param-name-list and type-param-def-stmts in the original order. Also fix a bug where a duplicate type-param-def caused a spurious extra error. If `MakeTypeSymbol()` reports an error we should not call `SetType()` because it will just report another error. Original-commit: flang-compiler/f18@3ca55b63333db3d779fe263583e3cb9fe7f4b2b1 Reviewed-on: https://github.com/flang-compiler/f18/pull/239
2018-12-07 09:52:43 +08:00
! type::t2(i,j,h)
! integer(4),len::h
! integer(4),kind::j
! integer(4),len::i
! end type
[flang] Resolve expressions in symbols Add `LazyExpr` class to represent expressions in the symbol table. Initially they contain a pointer to an expression in the parse tree. After name resolution is complete and symbols are filled in in the parse tree, `LazyExpr`s are resolved to `evaluate::Expr<evaluate::SomeType>`. This is done by `ResolveSymbolExprs()`. Change `Bound` and `ParamValue` to save their value as a `LazyExpr`. Change `ObjectEntityDetails` and `TypeParamDetails` to save the initial value as a `LazyExpr`. Eliminate `IntExpr` and `IntConst` classes, which were just place-holders. Add `Clone()` to `ShapeSpec`, `Bound`, `LazyExpr`. Normally they should be moved but in `ObjectEntityDetails::set_shape()` we need to make copies. Save type parameter values in `derivedTypeSpec_`. `typeParamValue_` is not needed. Write out initial values, type parameter values, and bounds to .mod files. Evaluate parameter values in expressions. Make some errors non-fatal so that tests can continue to pass. Original-commit: flang-compiler/f18@b90cadfc53c6e31c5f289eadc382bc3908811b86 Reviewed-on: https://github.com/flang-compiler/f18/pull/223 Tree-same-pre-rewrite: false
2018-11-07 09:18:06 +08:00
!contains
! subroutine foo(x)
[flang] fold analyzed bounds expressions Original-commit: flang-compiler/f18@17810319ae0236045c510c2c25d23a6fc32956ff Reviewed-on: https://github.com/flang-compiler/f18/pull/253
2019-01-08 08:31:59 +08:00
! real(4)::x(2_8:)
[flang] Resolve expressions in symbols Add `LazyExpr` class to represent expressions in the symbol table. Initially they contain a pointer to an expression in the parse tree. After name resolution is complete and symbols are filled in in the parse tree, `LazyExpr`s are resolved to `evaluate::Expr<evaluate::SomeType>`. This is done by `ResolveSymbolExprs()`. Change `Bound` and `ParamValue` to save their value as a `LazyExpr`. Change `ObjectEntityDetails` and `TypeParamDetails` to save the initial value as a `LazyExpr`. Eliminate `IntExpr` and `IntConst` classes, which were just place-holders. Add `Clone()` to `ShapeSpec`, `Bound`, `LazyExpr`. Normally they should be moved but in `ObjectEntityDetails::set_shape()` we need to make copies. Save type parameter values in `derivedTypeSpec_`. `typeParamValue_` is not needed. Write out initial values, type parameter values, and bounds to .mod files. Evaluate parameter values in expressions. Make some errors non-fatal so that tests can continue to pass. Original-commit: flang-compiler/f18@b90cadfc53c6e31c5f289eadc382bc3908811b86 Reviewed-on: https://github.com/flang-compiler/f18/pull/223 Tree-same-pre-rewrite: false
2018-11-07 09:18:06 +08:00
! end
! subroutine bar(x)
! real(4)::x(..)
! end
[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
! subroutine baz(x)
! type(*)::x
! end
[flang] Resolve expressions in symbols Add `LazyExpr` class to represent expressions in the symbol table. Initially they contain a pointer to an expression in the parse tree. After name resolution is complete and symbols are filled in in the parse tree, `LazyExpr`s are resolved to `evaluate::Expr<evaluate::SomeType>`. This is done by `ResolveSymbolExprs()`. Change `Bound` and `ParamValue` to save their value as a `LazyExpr`. Change `ObjectEntityDetails` and `TypeParamDetails` to save the initial value as a `LazyExpr`. Eliminate `IntExpr` and `IntConst` classes, which were just place-holders. Add `Clone()` to `ShapeSpec`, `Bound`, `LazyExpr`. Normally they should be moved but in `ObjectEntityDetails::set_shape()` we need to make copies. Save type parameter values in `derivedTypeSpec_`. `typeParamValue_` is not needed. Write out initial values, type parameter values, and bounds to .mod files. Evaluate parameter values in expressions. Make some errors non-fatal so that tests can continue to pass. Original-commit: flang-compiler/f18@b90cadfc53c6e31c5f289eadc382bc3908811b86 Reviewed-on: https://github.com/flang-compiler/f18/pull/223 Tree-same-pre-rewrite: false
2018-11-07 09:18:06 +08:00
!end