semantic error: `function` attribute of 'frexp' conflicts with `subroutine` attribute
  --> tests/errors/continue_compilation_1.f90:53:5 - 57:24
   |
53 |        subroutine frexp(x,n)
   |        ^^^^^^^^^^^^^^^^^^^^^...
...
   |
57 |        end subroutine frexp
   | ...^^^^^^^^^^^^^^^^^^^^^^^^ declared as subroutine here
   |
45 |        function frexp(x,n) result(r)
   |        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~...
...
   |
49 |        end function frexp
   | ...~~~~~~~~~~~~~~~~~~~~~~ previously declared as function here

semantic error: Derived type `another_undefined_type` is not defined
  --> tests/errors/continue_compilation_1.f90:79:9
   |
79 |         type(another_undefined_type) :: s3_in_subroutine
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Type used here is not defined in any scope

semantic error: c_char should have a length of 1
   --> tests/errors/continue_compilation_1.f90:103:9
    |
103 |         character(len=2, kind=c_char), intent(in) :: c
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Dummy argument 'c' not defined
   --> tests/errors/continue_compilation_1.f90:101:5 - 104:20
    |
101 |        subroutine s(c) bind(c)
    |        ^^^^^^^^^^^^^^^^^^^^^^^...
...
    |
104 |        end subroutine s
    | ...^^^^^^^^^^^^^^^^^^^^ 

semantic error: Assumed-size '*' is only permitted in the last dimension
   --> tests/errors/continue_compilation_1.f90:117:31
    |
117 |         real, intent(in) :: a(*, 10)
    |                               ^ 

semantic error: Dummy argument 'a' not defined
   --> tests/errors/continue_compilation_1.f90:116:5 - 118:18
    |
116 |        subroutine assumed_size_star_pos_1(a)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...
...
    |
118 |        end subroutine
    | ...^^^^^^^^^^^^^^^^^^ 

semantic error: Assumed-size '*' is only permitted in the last dimension
   --> tests/errors/continue_compilation_1.f90:121:19
    |
121 |         real :: a(*, 10)
    |                   ^ 

semantic error: Dummy argument 'a' not defined
   --> tests/errors/continue_compilation_1.f90:120:5 - 122:18
    |
120 |        subroutine assumed_size_star_pos_2(a)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...
...
    |
122 |        end subroutine
    | ...^^^^^^^^^^^^^^^^^^ 

warning: non-standard Fortran 77-style initialization (extension)
   --> tests/errors/continue_compilation_1.f90:162:27
    |
162 |             enumerator :: red/1/
    |                           ^^^^^^ Use modern syntax instead: integer :: red = 1

warning: non-standard Fortran 77-style initialization (extension)
   --> tests/errors/continue_compilation_1.f90:164:32
    |
164 |         type(MyClass), save :: slash_x/MyClass(1)/
    |                                ^^^^^^^^^^^^^^^^^^^ Use modern syntax instead: integer :: slash_x = MyClass(1)

warning: non-standard Fortran 77-style initialization (extension)
   --> tests/errors/continue_compilation_1.f90:165:26
    |
165 |         integer, save :: slash_y/2/
    |                          ^^^^^^^^^^ Use modern syntax instead: integer :: slash_y = 2

semantic error: Procedure declarations without an explicit interface (procedure()) are not yet supported. Please use procedure(interface_name) or declare an interface block.
   --> tests/errors/continue_compilation_1.f90:179:9
    |
179 |         procedure(), pointer :: pf1
    |         ^^^^^^^^^^^ 

semantic error: Procedure 'op_clash_f' is already defined as an interface body
   --> tests/errors/continue_compilation_1.f90:186:5 - 190:27
    |
186 |        function op_clash_f(x) result(y)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...
...
    |
190 |        end function op_clash_f
    | ...^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
    |
 35 |            function op_clash_f(x) result(y)
    |            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~...
...
    |
 38 |            end function
    | ...~~~~~~~~~~~~~~~~~~~~ is already defined here

semantic error: Defined assignment procedure must not return a value
   --> tests/errors/continue_compilation_1.f90:141:5 - 145:32
    |
141 |        integer function assign_func_bad(lhs, rhs)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...
...
    |
145 |        end function assign_func_bad
    | ...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Defined assignment procedure must have exactly two arguments
   --> tests/errors/continue_compilation_1.f90:147:5 - 149:37
    |
147 |        subroutine assign_wrong_nargs(lhs)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...
...
    |
149 |        end subroutine assign_wrong_nargs
    | ...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: First argument of defined assignment must have INTENT(OUT) or INTENT(INOUT)
   --> tests/errors/continue_compilation_1.f90:151:5 - 154:33
    |
151 |        subroutine assign_bad_lhs(lhs, rhs)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...
...
    |
154 |        end subroutine assign_bad_lhs
    | ...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Second argument of defined assignment must have INTENT(IN)
   --> tests/errors/continue_compilation_1.f90:156:5 - 159:33
    |
156 |        subroutine assign_bad_rhs(lhs, rhs)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...
...
    |
159 |        end subroutine assign_bad_rhs
    | ...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Interface 'f_missing' is referenced but not defined
  --> tests/errors/continue_compilation_1.f90:22:9
   |
22 |         procedure(f_missing), pointer, nopass :: fn => null()
   |         ^^^^^^^^^^^^^^^^^^^^ Referenced here

semantic error: Interface 'missing_global_interface' is referenced but not defined
  --> tests/errors/continue_compilation_1.f90:25:5
   |
25 |     procedure(missing_global_interface), pointer :: p => null()
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Referenced here

semantic error: Interface 'sub_test' is referenced but not defined
   --> tests/errors/continue_compilation_1.f90:182:9
    |
182 |         procedure(sub_test), pointer :: pf2
    |         ^^^^^^^^^^^^^^^^^^^ Referenced here

semantic error: Implicit typing is not allowed, enable it by using --implicit-typing 
   --> tests/errors/continue_compilation_1.f90:210:5 - 212:49
    |
210 |        implicit integer(a-f), real(e-z)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...
...
    |
212 |        ! Put declarations below without empty lines
    | ...^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: arguments of `repeat` intrinsic must be scalar
   --> tests/errors/continue_compilation_1.f90:233:38
    |
233 |     character(3), parameter :: ar1 = repeat(["abc", "#^1", "123"], [1, 2, 3])
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Cannot convert LOGICAL to REAL
   --> tests/errors/continue_compilation_1.f90:236:20
    |
236 |     real :: adwf = .true.
    |                    ^^^^^^ 

semantic error: Symbol is already declared in the same scope
   --> tests/errors/continue_compilation_1.f90:240:31
    |
240 |     integer , dimension(3) :: array
    |                               ^^^^^ redeclaration
    |
239 |     double precision array
    |                      ~~~~~ original declaration

semantic error: Array members must me of the same type as the struct
   --> tests/errors/continue_compilation_1.f90:244:53
    |
244 |     type(MyClass), parameter :: myclass_array(2) = [1, MyClass(10)]
    |                                                     ^ 

semantic error: Initialization of `myclass_array2` must reduce to a compile time constant.
   --> tests/errors/continue_compilation_1.f90:245:66
    |
245 |     type(MyClass), parameter :: myclass_array2(2) = [MyClass(1), MyClass(q1)]
    |                                                                  ^^^^^^^^^^^ 

semantic error: Syntax error in CHARACTER declaration: only 'len' and 'kind' are allowed as type parameters
   --> tests/errors/continue_compilation_1.f90:246:5
    |
246 |     character(width=10) :: str_c_1
    |     ^^^^^^^^^^^^^^^^^^^ 

semantic error: Syntax error in CHARACTER declaration: can't use a keyword argument more than once
   --> tests/errors/continue_compilation_1.f90:247:5
    |
247 |     character(len=10, len=20) :: str_c_2
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Syntax error in CHARACTER declaration: positional type parameters cannot follow a keyword argument
   --> tests/errors/continue_compilation_1.f90:248:5
    |
248 |     character(len=10, 1) :: str_c_3
    |     ^^^^^^^^^^^^^^^^^^^^ 

semantic error: Syntax error in CHARACTER declaration: using only 'len' keyword argument after a positional type is invalid
   --> tests/errors/continue_compilation_1.f90:249:5
    |
249 |     character(1, len=20) :: str_c_4
    |     ^^^^^^^^^^^^^^^^^^^^ 

semantic error: Allocatable array 'z_01' must have a deferred shape or assumed rank
   --> tests/errors/continue_compilation_1.f90:250:5
    |
250 |     character(:), allocatable :: z_01(2)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Expecting a scalar integer or parameter annotated integer variable 
   --> tests/errors/continue_compilation_1.f90:252:26
    |
252 |     logical :: mask_size(size(arr_size))
    |                          ^^^^^^^^^^^^^^ 

semantic error: `protected` attribute is only allowed in specification part of a module
   --> tests/errors/continue_compilation_1.f90:253:5
    |
253 |     integer, protected :: protected_attr_var
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `protected` attribute is only allowed in specification part of a module
   --> tests/errors/continue_compilation_1.f90:254:5
    |
254 |     integer, parameter, protected :: protected_parameter_var
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Variable `n` cannot appear in the expression as it is not a constant
   --> tests/errors/continue_compilation_1.f90:259:27
    |
259 |       integer :: elements(n)
    |                           ^ 

semantic error: Derived type `bspline_3d` is not defined
   --> tests/errors/continue_compilation_1.f90:261:5
    |
261 |     type(bspline_3d) :: s3_in_program
    |     ^^^^^^^^^^^^^^^^ Type used here is not defined in any scope

semantic error: BOZ literal constant cannot be used in binary operations
   --> tests/errors/continue_compilation_1.f90:263:19
    |
263 |     integer::tt = b'01' * 3
    |                   ^^^^^^^^^ 

semantic error: An 'allocatable' variable cannot have an initialization expression
   --> tests/errors/continue_compilation_1.f90:265:29
    |
265 |     integer, allocatable :: allocate_int = 1
    |                             ^^^^^^^^^^^^^^^^ 

semantic error: An 'allocatable' variable cannot have an initialization expression
   --> tests/errors/continue_compilation_1.f90:266:34
    |
266 |     character(:), allocatable :: allocate_char = "H"
    |                                  ^^^^^^^^^^^^^^^^^^^ 

semantic error: Transformational intrinsic is not permitted in an initialization expression
   --> tests/errors/continue_compilation_1.f90:270:42
    |
270 |     integer, parameter :: param_minloc = minloc(param_arr, 1, [.false., .false., .false.])
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Variable `uninitialized_param_local` with parameter attribute is not initialised
   --> tests/errors/continue_compilation_1.f90:278:5
    |
278 |     type(MyClass), parameter :: uninitialized_param_local
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Symbol not found: `non_existent_symbol`
   --> tests/errors/continue_compilation_1.f90:279:5
    |
279 |     type(MyClass) :: err_obj1 = non_existent_symbol
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Named initialization not supported with: my_func
   --> tests/errors/continue_compilation_1.f90:280:5
    |
280 |     type(MyClass) :: err_obj2 = my_func
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Initialization with non-constant variable `non_parameter_var` is not allowed
   --> tests/errors/continue_compilation_1.f90:282:5
    |
282 |     type(MyClass) :: err_obj3 = non_parameter_var
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
    |
281 |     integer :: non_parameter_var = 5
    |                ~~~~~~~~~~~~~~~~~~~~~ declared here

semantic error: Parameter `myclass_array` has no initialization value
   --> tests/errors/continue_compilation_1.f90:283:5
    |
283 |     type(MyClass) :: err_obj4 = myclass_array
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Symbol not found: `uninitialized_param_local`
   --> tests/errors/continue_compilation_1.f90:284:5
    |
284 |     type(MyClass) :: err_obj5 = uninitialized_param_local
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: CLASS variable 'inst_tt' must be dummy, allocatable or pointer
   --> tests/errors/continue_compilation_1.f90:295:5
    |
295 |     class(type_t) :: inst_tt
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Result of `erfc` underflows its kind
   --> tests/errors/continue_compilation_1.f90:296:40
    |
296 |     real(8), parameter :: erfc_param = erfc(40.12_8)
    |                                        ^^^^^^^^^^^^^ 

semantic error: Contiguous attribute can only be applied to declared variables
   --> tests/errors/continue_compilation_1.f90:298:19
    |
298 |     contiguous :: contig_not_declared
    |                   ^^^^^^^^^^^^^^^^^^^ 

semantic error: Contiguous attribute can only be applied to variables
   --> tests/errors/continue_compilation_1.f90:299:19
    |
299 |     contiguous :: MyClass
    |                   ^^^^^^^ 

semantic error: ‘shape’ argument of ‘reshape’ intrinsic has negative element (-2)
   --> tests/errors/continue_compilation_1.f90:302:53
    |
302 |     integer, parameter :: qval(2) = reshape([7, 8], -[z])
    |                                                     ^^^^ 

semantic error: LEN parameters in parameterized derived types are not supported yet
   --> tests/errors/continue_compilation_1.f90:305:9
    |
305 |         integer, len :: n
    |         ^^^^^^^^^^^^^^^^^ 

semantic error: Intent attribute can only be applied to procedure arguments
   --> tests/errors/continue_compilation_1.f90:614:14
    |
614 |     integer, intent(out) :: out_intent
    |              ^^^^^^^^^^^ 

semantic error: Intent attribute can only be applied to procedure arguments
   --> tests/errors/continue_compilation_1.f90:615:14
    |
615 |     integer, intent(in) :: in_intent
    |              ^^^^^^^^^^ 

semantic error: Parameterized derived type 'container' parameter 'ik' has no default value and must be specified
   --> tests/errors/continue_compilation_1.f90:626:5
    |
626 |     type(container(4)) :: obj1
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Parameterized derived type 'container' parameter 'rk' has no default value and must be specified
   --> tests/errors/continue_compilation_1.f90:627:5
    |
627 |     type(container) :: obj2
    |     ^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: The shapes of the `array` and `mask` arguments of the `MinLoc` intrinsic must be the same
   --> tests/errors/continue_compilation_1.f90:630:47
    |
630 |     integer :: minloc_shape_mismatch = minloc([2, 1, 3], 1, [.true., .false.])
    |                                               ^^^^^^^^^     ^^^^^^^^^^^^^^^^^ `array` has shape [3], but `mask` has shape [2]

semantic error: The shapes of the `array` and `mask` arguments of the `MaxLoc` intrinsic must be the same
   --> tests/errors/continue_compilation_1.f90:631:47
    |
631 |     integer :: maxloc_shape_mismatch = maxloc([2, 1, 3], 1, [.true., .false.])
    |                                               ^^^^^^^^^     ^^^^^^^^^^^^^^^^^ `array` has shape [3], but `mask` has shape [2]

semantic error: variable cannot appear in character length expression
   --> tests/errors/continue_compilation_1.f90:638:21
    |
638 |     character(len = char_len_var) :: char_nonconst
    |                     ^^^^^^^^^^^^ 

semantic error: type mismatch in initialization: `string` cannot be assigned to `integer`
   --> tests/errors/continue_compilation_1.f90:643:32
    |
643 |     integer, parameter :: n2 = "abc"
    |                                ^^^^^ 

semantic error: Pointer initialization target `ptr_src_no_target` must have the `target` attribute
   --> tests/errors/continue_compilation_1.f90:645:5
    |
645 |     type(MyClass), pointer :: ptr_requires_target => ptr_src_no_target
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
    |
644 |     type(MyClass) :: ptr_src_no_target
    |                      ~~~~~~~~~~~~~~~~~ declared here

semantic error: Type mismatch in pointer initialization of `ptr_type_mismatch`
   --> tests/errors/continue_compilation_1.f90:647:5
    |
647 |     type(MyClass), pointer :: ptr_type_mismatch => ptr_tgt_base
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
    |
646 |     type(Base), target :: ptr_tgt_base
    |                           ~~~~~~~~~~~~ target declared here

semantic error: Dimensions specified for 'm' after its initialization
   --> tests/errors/continue_compilation_1.f90:654:18
    |
654 |     dimension :: m(3)
    |                  ^^^^ 

semantic error: Cannot convert LOGICAL to REAL
   --> tests/errors/continue_compilation_1.f90:687:24
    |
687 |         real :: adwf = .true.
    |                        ^^^^^^ 

warning: Assuming implicit save attribute for variable declaration
   --> tests/errors/continue_compilation_1.f90:691:23
    |
691 |         integer(4) :: arr1(3) = [2471095, 820012001, 39024800]
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add explicit save attribute or parameter attribute or initialize in a separate statement

semantic error: Allocatable array 'x' must have a deferred shape or assumed rank
   --> tests/errors/continue_compilation_1.f90:717:9
    |
717 |         integer,allocatable  :: x(3)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Pointer array 'y' must have a deferred shape or assumed rank
   --> tests/errors/continue_compilation_1.f90:718:9
    |
718 |         integer,pointer  :: y(3)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: COMMON block array bounds must be constant expressions
   --> tests/errors/continue_compilation_1.f90:729:20
    |
729 |         integer :: arr(n:10)
    |                    ^^^^^^^^^ 

semantic error: COMMON block array bounds must be constant expressions
   --> tests/errors/continue_compilation_1.f90:736:20
    |
736 |         integer :: arr(1:n)
    |                    ^^^^^^^^ 

semantic error: Variable `a` cannot have both the OPTIONAL and VALUE attribute because procedure `bindc_optional_value` is BIND(C)
   --> tests/errors/continue_compilation_1.f90:748:5 - 751:18
    |
748 |        subroutine bindc_optional_value(a) bind(c)
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^...
...
    |
751 |        end subroutine
    | ...^^^^^^^^^^^^^^^^^^ 

semantic error: Function `c_loc` is not permitted in an initialization expression
   --> tests/errors/continue_compilation_1.f90:810:13
    |
810 |             type(c_ptr) :: ptr = c_loc(target_value)
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: length specifier is only valid for character type
   --> tests/errors/continue_compilation_1.f90:869:20
    |
869 |         integer :: i*2
    |                    ^^^ 

semantic error: Symbol 'undeclared_proc' not declared
   --> tests/errors/continue_compilation_1.f90:640:9
    |
640 |         module procedure undeclared_proc  ! {Error} Symbol 'undeclared_proc' not declared
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Statement function 'statement_function_name_conflict' conflicts with function name
  --> tests/errors/continue_compilation_1.f90:72:9
   |
72 |         statement_function_name_conflict(argument) = 0
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: The upper bound of an assumed-size array's last dimension is not defined
   --> tests/errors/continue_compilation_1.f90:111:18
    |
111 |         print *, ubound(a, 1)
    |                  ^^^^^^^^^^^^ 

semantic error: The DIM argument must be present when calling UBOUND on an assumed-size array
   --> tests/errors/continue_compilation_1.f90:112:18
    |
112 |         print *, ubound(b)
    |                  ^^^^^^^^^ 

semantic error: The upper bound of an assumed-size array's last dimension is not defined
   --> tests/errors/continue_compilation_1.f90:113:18
    |
113 |         print *, ubound(c, 2)
    |                  ^^^^^^^^^^^^ 

semantic error: Character intrinsic 'trim' with class(*) argument must be inside 'type is (character(len=*))' guard
   --> tests/errors/continue_compilation_1.f90:135:18
    |
135 |         print *, trim(generic)
    |                  ^^^^^^^^^^^^^ invalid use of character intrinsic with polymorphic argument

semantic error: Character intrinsic 'adjustl' with class(*) argument must be inside 'type is (character(len=*))' guard
   --> tests/errors/continue_compilation_1.f90:136:18
    |
136 |         print *, adjustl(generic)
    |                  ^^^^^^^^^^^^^^^^ invalid use of character intrinsic with polymorphic argument

semantic error: Character intrinsic 'adjustr' with class(*) argument must be inside 'type is (character(len=*))' guard
   --> tests/errors/continue_compilation_1.f90:137:18
    |
137 |         print *, adjustr(generic)
    |                  ^^^^^^^^^^^^^^^^ invalid use of character intrinsic with polymorphic argument

semantic error: Character intrinsic 'len_trim' with class(*) argument must be inside 'type is (character(len=*))' guard
   --> tests/errors/continue_compilation_1.f90:138:18
    |
138 |         print *, len_trim(generic)
    |                  ^^^^^^^^^^^^^^^^^ invalid use of character intrinsic with polymorphic argument

semantic error: Variable 'pf1' is not declared
   --> tests/errors/continue_compilation_1.f90:180:9
    |
180 |         pf1 => dummy_sub
    |         ^^^ 'pf1' is undeclared

semantic error: Interface mismatch in procedure pointer assignment at (1): 'dummy_func' is not a subroutine
   --> tests/errors/continue_compilation_1.f90:183:9
    |
183 |         pf2 => dummy_func
    |         ^^^^^^^^^^^^^^^^^ (1)

semantic error: Intrinsic 'not_real' is not recognized
   --> tests/errors/continue_compilation_1.f90:268:14
    |
268 |     call sub(not_real)
    |              ^^^^^^^^ 'not_real' is not a known intrinsic function

semantic error: Format specifier in print statement must be of type default character
   --> tests/errors/continue_compilation_1.f90:326:11
    |
326 |     print 1+2
    |           ^^^ 

semantic error: Array index 10 is out of bounds (1 to 3) in dimension 1
   --> tests/errors/continue_compilation_1.f90:328:14
    |
328 |     print *, a(10)
    |              ^^^^^ 

semantic error: Assignment to loop variable `i` is not allowed
   --> tests/errors/continue_compilation_1.f90:335:8
    |
335 |        i = i + 1
    |        ^ 

semantic error:  first argument of `maskl` must be less than or equal to the BIT_SIZE of INTEGER(KIND=4)
   --> tests/errors/continue_compilation_1.f90:339:13
    |
339 |     print*, maskl(63)
    |             ^^^^^^^^^ 

semantic error: first argument of `maskr` must be less than or equal to the BIT_SIZE of INTEGER(KIND=4)
   --> tests/errors/continue_compilation_1.f90:341:13
    |
341 |     print*, maskr(63)
    |             ^^^^^^^^^ 

semantic error: first argument of `maskl` must be nonnegative
   --> tests/errors/continue_compilation_1.f90:343:13
    |
343 |     print*, maskl(-24)
    |             ^^^^^^^^^^ 

semantic error: first argument of `maskr` must be nonnegative
   --> tests/errors/continue_compilation_1.f90:345:13
    |
345 |     print*, maskr(-24)
    |             ^^^^^^^^^^ 

semantic error: The argument `matrix_a` in `matmul` must be of type Integer, Real, Complex or Logical
   --> tests/errors/continue_compilation_1.f90:347:21
    |
347 |     print *, matmul(a1, b1)
    |                     ^^ 

semantic error: The argument `matrix_b` in `matmul` must be of type Integer, Real or Complex if first matrix is of numeric type
   --> tests/errors/continue_compilation_1.f90:349:25
    |
349 |     print *, matmul(b1, a1)
    |                         ^^ 

semantic error: The argument `matrix_b` in `matmul` must be of type Logical if first matrix is of Logical type
   --> tests/errors/continue_compilation_1.f90:351:25
    |
351 |     print *, matmul(a2, b1)
    |                         ^^ 

semantic error: `matmul` accepts arrays of rank 1 or 2 only, provided an array with rank, 3
   --> tests/errors/continue_compilation_1.f90:353:21
    |
353 |     print *, matmul(a3, b1)
    |                     ^^ 

semantic error: `matmul` accepts arrays of rank 1 or 2 only, provided an array with rank, 4
   --> tests/errors/continue_compilation_1.f90:355:25
    |
355 |     print *, matmul(b1, b4)
    |                         ^^ 

semantic error: The argument `matrix_b` in `matmul` must be of rank 2, provided an array with rank, 1
   --> tests/errors/continue_compilation_1.f90:357:24
    |
357 |     print *, matmul(a, b)
    |                        ^ 

semantic error: `transpose` accepts arrays of rank 2 only, provided an array with rank, 1
   --> tests/errors/continue_compilation_1.f90:359:24
    |
359 |     print *, transpose(a)
    |                        ^ 

semantic error: Type and kind of the relevant arguments of Mergebits must be the same
   --> tests/errors/continue_compilation_1.f90:361:14
    |
361 |     print *, merge_bits(8, 12_8, 2)
    |              ^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Type and kind of the relevant arguments of Mergebits must be the same
   --> tests/errors/continue_compilation_1.f90:363:14
    |
363 |     print *, merge_bits(a5, b5, c5)
    |              ^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Second argument of modulo cannot be 0
   --> tests/errors/continue_compilation_1.f90:379:14
    |
379 |     print *, modulo(1, 0)
    |              ^^^^^^^^^^^^ 

semantic error: Procedure 'my_func' accepts 2 arguments, but 3 were provided
   --> tests/errors/continue_compilation_1.f90:381:5
    |
381 |     call my_func(y=1, x=2, z=1)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ incorrect number of arguments to 'my_func'

semantic error: Result of `nint` overflows its kind(4)
   --> tests/errors/continue_compilation_1.f90:384:13
    |
384 |     print*, nint(1e12_8)
    |             ^^^^^^^^^^^^ 

semantic error: Result of `nint` overflows its kind(4)
   --> tests/errors/continue_compilation_1.f90:385:13
    |
385 |     print*, nint(1000000000000.0000000000000000d0)
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Invalid argument `hello` supplied
   --> tests/errors/continue_compilation_1.f90:387:5
    |
387 |     OPEN(file="numbers", hello="world")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Cannot assign to a constant variable
   --> tests/errors/continue_compilation_1.f90:389:5
    |
389 |     i1 = 3
    |     ^^^^^^ assignment here
    |
219 |     integer, parameter :: i1 = 2
    |                           ~~~~~~ declared as constant

semantic error: Expected 0 or 1 arguments, got 2 arguments instead.
   --> tests/errors/continue_compilation_1.f90:391:5
    |
391 |     call FLUSH(1, 2)
    |     ^^^^^^^^^^^^^^^^ 

semantic error: `kind` argument of `verify` intrinsic must be a scalar
   --> tests/errors/continue_compilation_1.f90:393:39
    |
393 |     print*, verify(string, set, kind= [4, 4] )
    |                                       ^^^^^^ 

semantic error: arguments of `and` intrinsic must be scalar
   --> tests/errors/continue_compilation_1.f90:394:14
    |
394 |     print *, and([1, 2, 3], [1, 2, 3])
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: The shift argument of 'dshiftl' intrinsic must be less than or equal to the bit size of the integer
   --> tests/errors/continue_compilation_1.f90:396:28
    |
396 |     print *, dshiftl(1, 2, 34)
    |                            ^^ 

semantic error: The shift argument of 'dshiftl' intrinsic must be non-negative integer
   --> tests/errors/continue_compilation_1.f90:397:28
    |
397 |     print *, dshiftl(1, 2, -2)
    |                            ^^ 

semantic error: The shift argument of 'dshiftr' intrinsic must be less than or equal to the bit size of the integer
   --> tests/errors/continue_compilation_1.f90:399:28
    |
399 |     print *, dshiftr(1, 2, 34)
    |                            ^^ 

semantic error: The shift argument of 'dshiftr' intrinsic must be non-negative integer
   --> tests/errors/continue_compilation_1.f90:400:28
    |
400 |     print *, dshiftr(1, 2, -2)
    |                            ^^ 

semantic error: arguments of `selected_int_kind` intrinsic must be scalar
   --> tests/errors/continue_compilation_1.f90:402:14
    |
402 |     print *, selected_int_kind([1,2,3])
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: arguments of `selected_real_kind` intrinsic must be scalar
   --> tests/errors/continue_compilation_1.f90:403:14
    |
403 |     print *, selected_real_kind([1,2,3])
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: arguments of `selected_char_kind` intrinsic must be scalar
   --> tests/errors/continue_compilation_1.f90:404:14
    |
404 |     print *, selected_char_kind(['c', 'a', 'b'])
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `dim` argument of the `Sum` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:413:30
    |
413 |     print *, sum(arr1, dim = 2)
    |                              ^ Must have 0 < dim <= 1 for array of rank 1

semantic error: `dim` argument of the `Sum` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:414:30
    |
414 |     print *, sum(arr1, dim = -1)
    |                              ^^ Must have 0 < dim <= 1 for array of rank 1

semantic error: `dim` argument of the `Sum` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:415:44
    |
415 |     print *, sum(arr1, mask = mask1, dim = 2)
    |                                            ^ Must have 0 < dim <= 1 for array of rank 1

semantic error: `dim` argument of the `Sum` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:416:44
    |
416 |     print *, sum(arr1, mask = mask1, dim = -1)
    |                                            ^^ Must have 0 < dim <= 1 for array of rank 1

semantic error: `dim` argument of the `Product` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:418:34
    |
418 |     print *, product(arr2, dim = 3)
    |                                  ^ Must have 0 < dim <= 2 for array of rank 2

semantic error: `dim` argument of the `Product` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:419:34
    |
419 |     print *, product(arr2, dim = -1)
    |                                  ^^ Must have 0 < dim <= 2 for array of rank 2

semantic error: `dim` argument of the `Product` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:420:48
    |
420 |     print *, product(arr2, mask = mask2, dim = 3)
    |                                                ^ Must have 0 < dim <= 2 for array of rank 2

semantic error: `dim` argument of the `Product` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:421:48
    |
421 |     print *, product(arr2, mask = mask2, dim = -1)
    |                                                ^^ Must have 0 < dim <= 2 for array of rank 2

semantic error: `dim` argument of the `Iparity` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:423:34
    |
423 |     print *, iparity(arr3, dim = 4)
    |                                  ^ Must have 0 < dim <= 3 for array of rank 3

semantic error: `dim` argument of the `Iparity` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:424:34
    |
424 |     print *, iparity(arr3, dim = -1)
    |                                  ^^ Must have 0 < dim <= 3 for array of rank 3

semantic error: `dim` argument of the `Iparity` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:425:48
    |
425 |     print *, iparity(arr3, mask = mask3, dim = 4)
    |                                                ^ Must have 0 < dim <= 3 for array of rank 3

semantic error: `dim` argument of the `Iparity` intrinsic is out of bounds
   --> tests/errors/continue_compilation_1.f90:426:48
    |
426 |     print *, iparity(arr3, mask = mask3, dim = -1)
    |                                                ^^ Must have 0 < dim <= 3 for array of rank 3

semantic error: Expected logical expression in if statement, but recieved integer(4) instead
   --> tests/errors/continue_compilation_1.f90:428:9
    |
428 |     if (q1) q1 = 1
    |         ^^ integer(4) expression, expected logical

semantic error: Expected logical expression in if statement, but recieved real(4) instead
   --> tests/errors/continue_compilation_1.f90:429:9
    |
429 |     if (r1) r1 = 1.0
    |         ^^ real(4) expression, expected logical

semantic error: Expected logical expression in if statement, but recieved string instead
   --> tests/errors/continue_compilation_1.f90:430:9
    |
430 |     if (c1) c1 = 'a'
    |         ^^ string expression, expected logical

semantic error: The ranks of the `array` and `mask` arguments of the `Sum` intrinsic must be the same
   --> tests/errors/continue_compilation_1.f90:435:18
    |
435 |     print *, sum(arr1, mask2)
    |                  ^^^^  ^^^^^ `array` is rank 1, but `mask` is rank 2

semantic error: `dim` argument of `Sum` intrinsic must be INTEGER
   --> tests/errors/continue_compilation_1.f90:436:24
    |
436 |     print *, sum(arr2, mask3, 2)
    |                        ^^^^^ 

semantic error: The shapes of the `array` and `mask` arguments of the `Iparity` intrinsic must be the same
   --> tests/errors/continue_compilation_1.f90:437:22
    |
437 |     print *, iparity(arr2, mask4)
    |                      ^^^^  ^^^^^ `array` has shape [2,3], but `mask` has shape [3,2]

semantic error: `dim` argument of `Iparity` intrinsic must be INTEGER
   --> tests/errors/continue_compilation_1.f90:438:28
    |
438 |     print *, iparity(arr3, mask5, 3)
    |                            ^^^^^ 

semantic error: Argument to 'present' must be a variable, but got an expression
   --> tests/errors/continue_compilation_1.f90:441:22
    |
441 |     print *, present(a + 1)
    |                      ^^^^^ Expected a variable here

semantic error: Argument to 'present' must be an optional dummy argument
   --> tests/errors/continue_compilation_1.f90:444:22
    |
444 |     print *, present(a)
    |                      ^ This variable is not 'optional'

semantic error: Different shape for arguments `array` and `mask` for pack intrinsic (3 and 4)
   --> tests/errors/continue_compilation_1.f90:446:30
    |
446 |     print *, pack([1, 2, 3], [.true., .true., .true., .true.])
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: reshape accepts arrays for `source` argument, found string instead.
   --> tests/errors/continue_compilation_1.f90:448:22
    |
448 |     print *, reshape("hello", [2, 3])
    |                      ^^^^^^^ 

semantic error: reshape accepts arrays for `source` argument, found logical instead.
   --> tests/errors/continue_compilation_1.f90:449:22
    |
449 |     print *, reshape(.true., [2, 3])
    |                      ^^^^^^ 

semantic error: reshape accepts arrays for `shape` argument, found string instead.
   --> tests/errors/continue_compilation_1.f90:450:36
    |
450 |     print *, reshape([1, 2, 3, 4], "hello")
    |                                    ^^^^^^^ 

semantic error: reshape accepts arrays for `shape` argument, found logical instead.
   --> tests/errors/continue_compilation_1.f90:451:36
    |
451 |     print *, reshape([1, 2, 3, 4], .false.)
    |                                    ^^^^^^^ 

semantic error: reshape accepts `source` array with size greater than or equal to size specified by `shape` array
   --> tests/errors/continue_compilation_1.f90:453:14
    |
453 |     print *, reshape([1, 2, 3, 4], [2, 3])
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `shape` specifies size of 6 which exceeds the `source` array size of 4

semantic error: Division by zero
   --> tests/errors/continue_compilation_1.f90:456:14
    |
456 |     print *, 1/0
    |              ^^^ 

semantic error: Division by zero
   --> tests/errors/continue_compilation_1.f90:457:14
    |
457 |     print *, x/zero
    |              ^^^^^^ 

semantic error: Type mismatch in binary operator, the types must be compatible
   --> tests/errors/continue_compilation_1.f90:458:14
    |
458 |     print *, v**str
    |              ^  ^^^ type mismatch (real and string)

semantic error: Type mismatch in binary operator, the types must be compatible
   --> tests/errors/continue_compilation_1.f90:459:14
    |
459 |     print *, str**v
    |              ^^^  ^ type mismatch (string and real)

semantic error: The shift argument of 'shiftl' intrinsic must be less than or equal to the bit size of the integer
   --> tests/errors/continue_compilation_1.f90:461:24
    |
461 |     print *, shiftl(2, 34)
    |                        ^^ Shift value is 34, but bit size of integer is 32

semantic error: The shift argument of 'shiftl' intrinsic must be non-negative integer
   --> tests/errors/continue_compilation_1.f90:462:24
    |
462 |     print *, shiftl(2, -3)
    |                        ^^ 

semantic error: The shift argument of 'shiftr' intrinsic must be less than or equal to the bit size of the integer
   --> tests/errors/continue_compilation_1.f90:463:24
    |
463 |     print *, shiftr(2, 34)
    |                        ^^ Shift value is 34, but bit size of integer is 32

semantic error: The shift argument of 'shiftr' intrinsic must be non-negative integer
   --> tests/errors/continue_compilation_1.f90:464:24
    |
464 |     print *, shiftr(2, -3)
    |                        ^^ 

semantic error: The shift argument of 'rshift' intrinsic must be less than or equal to the bit size of the integer
   --> tests/errors/continue_compilation_1.f90:465:24
    |
465 |     print *, rshift(2, 34)
    |                        ^^ Shift value is 34, but bit size of integer is 32

semantic error: The shift argument of 'rshift' intrinsic must be non-negative integer
   --> tests/errors/continue_compilation_1.f90:466:24
    |
466 |     print *, rshift(2, -3)
    |                        ^^ 

semantic error: Input to `Sum` is expected to be numeric, but got string[:]
   --> tests/errors/continue_compilation_1.f90:468:18
    |
468 |     print *, sum([c1])
    |                  ^^^^ must be integer, real or complex type

semantic error: Input to `Product` is expected to be numeric, but got string[:]
   --> tests/errors/continue_compilation_1.f90:469:22
    |
469 |     print *, product([c1])
    |                      ^^^^ must be integer, real or complex type

semantic error: Input to `MinVal` is expected to be of integer, real or character type, but got complex[:]
   --> tests/errors/continue_compilation_1.f90:470:21
    |
470 |     print *, minval([c])
    |                     ^^^ must be integer, real or character type

semantic error: Input to `MaxVal` is expected to be of integer, real or character type, but got complex[:]
   --> tests/errors/continue_compilation_1.f90:471:21
    |
471 |     print *, maxval([c])
    |                     ^^^ must be integer, real or character type

semantic error: Argument to intrinsic `Sum` is expected to be an array, found: integer
   --> tests/errors/continue_compilation_1.f90:473:14
    |
473 |     print *, sum(q1)
    |              ^^^^^^^ 

semantic error: Argument to intrinsic `Product` is expected to be an array, found: real
   --> tests/errors/continue_compilation_1.f90:474:14
    |
474 |     print *, product(r1)
    |              ^^^^^^^^^^^ 

semantic error: Argument to intrinsic `MinVal` is expected to be an array, found: integer
   --> tests/errors/continue_compilation_1.f90:475:14
    |
475 |     print *, minval(q1)
    |              ^^^^^^^^^^ 

semantic error: Argument to intrinsic `MaxVal` is expected to be an array, found: real
   --> tests/errors/continue_compilation_1.f90:476:14
    |
476 |     print *, maxval(r1)
    |              ^^^^^^^^^^ 

semantic error: 'mask' argument of 'sum' intrinsic must be logical
   --> tests/errors/continue_compilation_1.f90:478:14
    |
478 |     print *, sum([1, 2, 3], mask = [1, 2, 3])
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Type mismatch in assignment, the types must be compatible
   --> tests/errors/continue_compilation_1.f90:479:5
    |
479 |     z1 = y 
    |     ^^   ^ type mismatch (real and logical)

semantic error: reshape accepts arrays for `pad` argument, found integer instead.
   --> tests/errors/continue_compilation_1.f90:481:50
    |
481 |     print *, reshape([1, 2, 3, 4, 5, 6], [2, 3], 0)
    |                                                  ^ 

semantic error: reshape accepts arrays for `order` argument, found integer instead.
   --> tests/errors/continue_compilation_1.f90:482:55
    |
482 |     print *, reshape([1, 2, 3, 4, 5, 6], [2, 3], [0], 0)
    |                                                       ^ 

semantic error: `pad` argument of reshape intrinsic must have same type and kind as `source` argument, found pad type real(4) source type integer(4) instead.
   --> tests/errors/continue_compilation_1.f90:483:50
    |
483 |     print *, reshape([1, 2, 3, 4, 5, 6], [2, 3], [1.2])
    |                                                  ^^^^^ 

semantic error: `pad` argument of reshape intrinsic must have same type and kind as `source` argument, found pad type integer(8) source type integer(4) instead.
   --> tests/errors/continue_compilation_1.f90:484:50
    |
484 |     print *, reshape([1, 2, 3, 4, 5, 6], [2, 3], [0_8])
    |                                                  ^^^^^ 

semantic error: reshape accepts `order` array with integer elements
   --> tests/errors/continue_compilation_1.f90:486:58
    |
486 |     print *, reshape([1, 2, 3, 4, 5, 6], [2, 3], order = [1.0, 2.0])
    |                                                          ^^^^^^^^^^ 

semantic error: reshape accepts `order` array as a permutation of elements from 1 to 2
   --> tests/errors/continue_compilation_1.f90:487:58
    |
487 |     print *, reshape([1, 2, 3, 4, 5, 6], [2, 3], order = [2, 3])
    |                                                          ^^^^^^ 

semantic error: Substring start index must be of type integer
   --> tests/errors/continue_compilation_1.f90:488:16
    |
488 |     print *, a(b'01':2)
    |                ^^^^^ 

semantic error: `mask` argument to `count` intrinsic must be a logical array
   --> tests/errors/continue_compilation_1.f90:489:20
    |
489 |     print *, count(1)
    |                    ^ 

semantic error: `mask` argument to `count` intrinsic must be a logical array
   --> tests/errors/continue_compilation_1.f90:490:20
    |
490 |     print *, count([2])
    |                    ^^^ 

semantic error: Substring stride must be of type integer
   --> tests/errors/continue_compilation_1.f90:491:20
    |
491 |     print *, a(1:2:b'10')
    |                    ^^^^^ 

semantic error: Type mismatch in assignment, the types must be compatible
   --> tests/errors/continue_compilation_1.f90:492:5
    |
492 |     a_real = [logical::]
    |     ^^^^^^   ^^^^^^^^^^^ type mismatch (real[:] and logical[:])

semantic error: Subroutine `dummy_sub` called as a function
   --> tests/errors/continue_compilation_1.f90:494:14
    |
494 |     print *, dummy_sub()
    |              ^^^^^^^^^^^ 

semantic error: Input to `Iparity` is expected to be an integer, but got string[:]
   --> tests/errors/continue_compilation_1.f90:495:22
    |
495 |     print *, iparity(["a", "b"])
    |                      ^^^^^^^^^^ must be of integer type

semantic error: The `mask` argument to `parity` must be logical, but got string[:]
   --> tests/errors/continue_compilation_1.f90:496:21
    |
496 |     print *, parity(["a", "b"])
    |                     ^^^^^^^^^^ must be logical type

semantic error: Substring end index exceeds the string length
   --> tests/errors/continue_compilation_1.f90:497:14
    |
497 |     print *, string(1:6)
    |              ^^^^^^^^^^^ 

semantic error: `shape` array in reshape intrinsic should be of constant size
   --> tests/errors/continue_compilation_1.f90:499:30
    |
499 |     matrix = reshape(source, shape_, pad=[0])
    |                              ^^^^^^ not a constant size array

semantic error: Incompatible ranks 2 and 1 in assignment
   --> tests/errors/continue_compilation_1.f90:499:5
    |
499 |     matrix = reshape(source, shape_, pad=[0])
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Complex variable 'c' only has %re, %im, and %kind members, not 'mymember'
   --> tests/errors/continue_compilation_1.f90:504:14
    |
504 |     print *, c%mymember
    |              ^^^^^^^^^^ 

semantic error: Character variable 'c1' only has %len and %kind members, not 'mymember'
   --> tests/errors/continue_compilation_1.f90:506:14
    |
506 |     print *, c1%mymember
    |              ^^^^^^^^^^^ 

semantic error: Substring end index must be of type integer
   --> tests/errors/continue_compilation_1.f90:507:23
    |
507 |     print *, string(1:Z'100000003')
    |                       ^^^^^^^^^^^^ 

semantic error: Incorrect number of arguments passed to the 'present' intrinsic. It accepts exactly 1 arguments.
   --> tests/errors/continue_compilation_1.f90:508:14
    |
508 |     print *, present(x,x)
    |              ^^^^^^^^^^^^ 

semantic error: Incorrect number of arguments passed to the 'present' intrinsic. It accepts exactly 1 arguments.
   --> tests/errors/continue_compilation_1.f90:509:14
    |
509 |     print *, present()
    |              ^^^^^^^^^ 

semantic error: Incorrect number of arguments passed to the 'ieor' intrinsic. It accepts exactly 2 arguments.
   --> tests/errors/continue_compilation_1.f90:510:14
    |
510 |     print *, ieor(x)
    |              ^^^^^^^ 

semantic error: Incorrect number of arguments passed to the 'ieor' intrinsic. It accepts exactly 2 arguments.
   --> tests/errors/continue_compilation_1.f90:511:14
    |
511 |     print *, ieor()
    |              ^^^^^^ 

semantic error: Arguments to min0 must be of real, integer or character type
   --> tests/errors/continue_compilation_1.f90:512:14
    |
512 |     print *, min(c, c)
    |              ^^^^^^^^^ 

semantic error: `exit` statements cannot be outside of loops or blocks
   --> tests/errors/continue_compilation_1.f90:513:5
    |
513 |     exit
    |     ^^^^ 

semantic error: `cycle` statements cannot be outside of loops
   --> tests/errors/continue_compilation_1.f90:514:5
    |
514 |     cycle
    |     ^^^^^ 

semantic error: Required argument `y` at position 2 is missing in procedure call
   --> tests/errors/continue_compilation_1.f90:516:18
    |
516 |     call my_func(10)
    |                  ^^ 

semantic error: Required argument `x` is missing in procedure call
   --> tests/errors/continue_compilation_1.f90:517:5
    |
517 |     call my_func()
    |     ^^^^^^^^^^^^^^ 

semantic error: Required argument `extra_arg` is missing in procedure call
   --> tests/errors/continue_compilation_1.f90:521:5
    |
521 |     call obj%display()
    |     ^^^^^^^^^^^^^^^^^^ 

semantic error: Shape mismatch in `allocate` statement.
   --> tests/errors/continue_compilation_1.f90:523:14
    |
523 |     allocate(arr4(5), source=[1, 2, 3])
    |              ^^^^^^^         ^^^^^^^^^ shape mismatch in dimension 1

semantic error: Type mismatch: The `source` argument in `allocate` must have the same type as the allocated variable.
Expected type: integer[:] allocatable, but got: real.
   --> tests/errors/continue_compilation_1.f90:524:14
    |
524 |     allocate(arr4(5), source=v)
    |              ^^^^^^^         ^ incompatible types in `allocate` statement

semantic error: Dimension mismatch in `allocate` statement.
   --> tests/errors/continue_compilation_1.f90:525:14
    |
525 |     allocate(arr4(3), source=reshape([1, 2, 3, 4, 5, 6], [2, 3]))
    |              ^^^^^^^         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mismatch in dimensions between allocated variable and `source`

semantic error: Cannot allocate an array from a scalar source.
   --> tests/errors/continue_compilation_1.f90:526:14
    |
526 |     allocate(arr4, source=7)
    |              ^^^^ allocated variable is an array, but `source` is a scalar

semantic error: Argument was not specified
   --> tests/errors/continue_compilation_1.f90:528:5
    |
528 |     call logger % add_log_file(filename=filename)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 1-th argument not specified for add_log_file

semantic error: Required argument `unit` is missing in procedure call
   --> tests/errors/continue_compilation_1.f90:529:5
    |
529 |     call logger % add_log_file()
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `allocate` statement only accepts four keyword arguments: `stat`, `errmsg`, `source` and `mold`
   --> tests/errors/continue_compilation_1.f90:531:5
    |
531 |     allocate(arr5, status=q1)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Different `character` lengths 2 and 3 in array constructor
   --> tests/errors/continue_compilation_1.f90:534:21
    |
534 |     print *, ["aa", "aaa"]
    |                     ^^^^^ 

semantic error: Different shape for array assignment on dimension 1(2 and 1)
   --> tests/errors/continue_compilation_1.f90:535:5
    |
535 |     cc_a3 = cc_temp3(cc_i0:cc_i0)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: The argument `mask` must be of rank 2, an array with rank 1 was provided.
   --> tests/errors/continue_compilation_1.f90:536:25
    |
536 |     print *, pack(arr2, mask1)
    |                         ^^^^^ 

semantic error: Variable protected_module_my_class_obj is PROTECTED and cannot appear in LHS of assignment
   --> tests/errors/continue_compilation_1.f90:539:5
    |
539 |     protected_module_my_class_obj%value = 42
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Different shape for array assignment on dimension 1(2 and 1)
   --> tests/errors/continue_compilation_1.f90:540:5
    |
540 |     cc_a4 = cc_temp4(cc_i1+1:cc_i1+1)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Invalid syntax of derived type for array constructor
   --> tests/errors/continue_compilation_1.f90:541:12
    |
541 |     arr = [type(MyClass) :: v1, v2, v3]
    |            ^^^^^^^^^^^^^ help: use just the derived type name 'myclass', without the keyword 'type'

semantic error: Class type `NonExistingType` is not defined
   --> tests/errors/continue_compilation_1.f90:543:11
    |
543 |     arr = [NonExistingType :: v1, v2, v3]
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: DATA statement element count mismatch: 8 elements on left-hand side, 10 values on right-hand side
   --> tests/errors/continue_compilation_1.f90:546:5
    |
546 |     data j2, x2, (y2(i2), i2=1,3), k2 / 1,2,3,4,5,6,7,3*8 /
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: DO loop label 'q1' already defined
   --> tests/errors/continue_compilation_1.f90:548:9 - 550:10
    |
548 |        q1: do q1 = 1, 3
    |            ^^^^^^^^^^^^...
...
    |
550 |        end do q1
    | ...^^^^^^^^^^ 

semantic error: Assigned format (using integer variable as format specifier) is not supported. Use character variables instead.
   --> tests/errors/continue_compilation_1.f90:555:5
    |
555 |     WRITE (6, fmt_i1)
    |     ^^^^^^^^^^^^^^^^^ 

semantic error: Assigned format (using integer variable as format specifier) is not supported. Use character variables instead.
   --> tests/errors/continue_compilation_1.f90:560:5
    |
560 |     print fmt_i2, "test"
    |     ^^^^^^^^^^^^^^^^^^^^ 

semantic error: Assigned format (using integer variable as format specifier) is not supported. Use character variables instead.
   --> tests/errors/continue_compilation_1.f90:565:5
    |
565 |     read (5, fmt_i3)
    |     ^^^^^^^^^^^^^^^^ 

semantic error: Type mismatch in argument `p`: expected a procedure but got `integer`
   --> tests/errors/continue_compilation_1.f90:568:21
    |
568 |     call proc_param(42)
    |                     ^^ 

semantic error: `end` must be a literal integer label
   --> tests/errors/continue_compilation_1.f90:571:18
    |
571 |     read (*, end=x) x
    |                  ^ 

semantic error: `end` must be a literal integer label
   --> tests/errors/continue_compilation_1.f90:572:18
    |
572 |     read (*, end=9011.0) x
    |                  ^^^^^^ 

semantic error: `err` must be a literal integer label
   --> tests/errors/continue_compilation_1.f90:574:18
    |
574 |     read (*, err=x) x
    |                  ^ 

semantic error: `err` must be a literal integer label
   --> tests/errors/continue_compilation_1.f90:575:18
    |
575 |     read (*, err=9013.0) x
    |                  ^^^^^^ 

semantic error: `end` is only supported for READ statements
   --> tests/errors/continue_compilation_1.f90:576:5
    |
576 |     write (*, end=9014) x
    |     ^^^^^^^^^^^^^^^^^^^^^ 

semantic error: end= label 999 is not defined
   --> tests/errors/continue_compilation_1.f90:581:20
    |
581 |     read(*, *, end=999) x   
    |                    ^^^ 

semantic error: err= label 500 is not defined
   --> tests/errors/continue_compilation_1.f90:582:20
    |
582 |     read(*, *, err=500) x
    |                    ^^^ 

semantic error: Duplicate value of `recl` found, it has already been specified via arguments or keyword arguments
   --> tests/errors/continue_compilation_1.f90:584:5
    |
584 |     OPEN(unit=10, recl=10, recl=20)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `recl` must be of type, Integer
   --> tests/errors/continue_compilation_1.f90:585:5
    |
585 |     OPEN(unit=10, recl=10.5)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Invalid substring syntax: use lower:upper instead of lower,upper
   --> tests/errors/continue_compilation_1.f90:588:14
    |
588 |     print *, string(i,i)
    |              ^^^^^^^^^^^ 

semantic error: Allocate should only be called with Allocatable or Pointer type inputs, found str
   --> tests/errors/continue_compilation_1.f90:590:14
    |
590 |     allocate(strx)
    |              ^^^^ 'strx' is not allocatable or pointer

semantic error: Type mismatch: allocatable character dummy argument 's' has length 5 but actual argument has length 10.
   --> tests/errors/continue_compilation_1.f90:592:32
    |
592 |     call modify_and_deallocate(strx)
    |                                ^^^^ dummy argument 's' declared here

semantic error: Intrinsic `allocated` can be called only on allocatable argument
   --> tests/errors/continue_compilation_1.f90:593:14
    |
593 |     print *, allocated(strx)
    |              ^^^^^^^^^^^^^^^ 

semantic error: Duplicate value of `encoding` found
   --> tests/errors/continue_compilation_1.f90:597:5
    |
597 |     OPEN(unit=10, encoding="UTF-8", encoding="UTF-8")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `encoding` must be of type, String or StringPointer
   --> tests/errors/continue_compilation_1.f90:598:5
    |
598 |     OPEN(unit=10, encoding=10)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `rec` specifier is not allowed for internal file I/O
   --> tests/errors/continue_compilation_1.f90:601:5
    |
601 |     read(str_var, rec=1) x
    |     ^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `rec` specifier is not allowed for internal file I/O
   --> tests/errors/continue_compilation_1.f90:602:5
    |
602 |     write(str_var, rec=1) x
    |     ^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Duplicate value of `rec` found, it has already been specified via arguments or keyword arguments
   --> tests/errors/continue_compilation_1.f90:603:5
    |
603 |     read(unit=10, rec=1, rec=2) y
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Duplicate value of `rec` found, it has already been specified via arguments or keyword arguments
   --> tests/errors/continue_compilation_1.f90:604:5
    |
604 |     write(unit=10, rec=1, rec=2) y
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `rec` must be of type, Integer
   --> tests/errors/continue_compilation_1.f90:605:5
    |
605 |     read(10, rec=1.5) y
    |     ^^^^^^^^^^^^^^^^^^^ 

semantic error: `rec` must be of type, Integer
   --> tests/errors/continue_compilation_1.f90:606:5
    |
606 |     write(10, rec=2.5) y
    |     ^^^^^^^^^^^^^^^^^^^^ 

semantic error: `bad` is not defined or imported
   --> tests/errors/continue_compilation_1.f90:609:13
    |
609 |     bad_x = .bad. 10
    |             ^^^^^^^^ 

semantic error: `op` is not defined or imported
   --> tests/errors/continue_compilation_1.f90:610:13
    |
610 |     bad_x = 5 .op. 3
    |             ^^^^^^^^ 

semantic error: Operands of comparison operator '==' are not comparable: ieee_class_type == ieee_class_type
   --> tests/errors/continue_compilation_1.f90:612:10
    |
612 |     b = (ieee_cls == ieee_quiet_nan)
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Type mismatch in assignment, the types must be compatible
   --> tests/errors/continue_compilation_1.f90:612:5
    |
612 |     b = (ieee_cls == ieee_quiet_nan)
    |     ^                ^^^^^^^^^^^^^^ type mismatch (integer[:] and ieee_class_type)

semantic error: Type mismatch in assignment, the types must be compatible
   --> tests/errors/continue_compilation_1.f90:617:5
    |
617 |     base_var = derived_var
    |     ^^^^^^^^   ^^^^^^^^^^^ type mismatch (base and derived)

semantic error: Implied DO loop must be enclosed within array constructor brackets [...]; expected '[( ... )]' in assignment
   --> tests/errors/continue_compilation_1.f90:629:15
    |
629 |     arr_idl = (i, i = 1, 4)
    |               ^^^^^^^^^^^^^ 

semantic error: ADVANCE= specifier must have value = YES or NO
   --> tests/errors/continue_compilation_1.f90:632:30
    |
632 |     write (*, "(a)", advance="hello") "Dothraki culture"
    |                              ^^^^^^^ 

semantic error: 'dim' argument of 'sum' intrinsic must be INTEGER
   --> tests/errors/continue_compilation_1.f90:633:30
    |
633 |     print *, sum(arr1, dim = mask1)
    |                              ^^^^^ 

semantic error: 'ieee_is_nan' is not accessible in the current scope; add 'use, intrinsic :: ieee_arithmetic' to use it
   --> tests/errors/continue_compilation_1.f90:634:13
    |
634 |     print*, ieee_is_nan(1.0)
    |             ^^^^^^^^^^^^^^^^ not in scope

semantic error: `decimal` must be of type, String or StringPointer
   --> tests/errors/continue_compilation_1.f90:635:5
    |
635 |     open(unit=7, decimal=1, decimal="comma")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Duplicate value of `decimal` found
   --> tests/errors/continue_compilation_1.f90:636:5
    |
636 |     open(unit=7, decimal="POINT", decimal="comma")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Missing 'boundary' argument to 'eoshift' intrinsic
   --> tests/errors/continue_compilation_1.f90:642:38
    |
642 |     eoshift_derived_result = eoshift(eoshift_derived_array, 1)
    |                                      ^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Implicit casting from LOGICAL to INTEGER is not allowed by default. Use `--logical-casting` flag to enable it.
   --> tests/errors/continue_compilation_1.f90:648:5
    |
648 |     a(1) = .true.
    |     ^^^^^^^^^^^^^ 

semantic error: Type mismatch in assignment, the types must be compatible
   --> tests/errors/continue_compilation_1.f90:649:5
    |
649 |     derived_cls = base_var
    |     ^^^^^^^^^^^   ^^^^^^^^ type mismatch (derived and base)

warning: Real constant overflows its kind (4)
   --> tests/errors/continue_compilation_1.f90:651:15
    |
651 |     print  *, 9.99e+99
    |               ^^^^^^^^ 

semantic error: Missing actual argument for argument 'stat'
   --> tests/errors/continue_compilation_1.f90:652:10
    |
652 |     a5 = missing_required_arg_func()
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `asynchronous` must be of type String
   --> tests/errors/continue_compilation_1.f90:655:69
    |
655 |     open(newunit=u, file="test.dat", status="replace", asynchronous=1)
    |                                                                     ^ 

semantic error: Duplicate value of `asynchronous` found
   --> tests/errors/continue_compilation_1.f90:656:89
    |
656 |     open(newunit=u, file="test.dat", status="replace", asynchronous="yes", asynchronous="no")
    |                                                                                         ^^^^ 

semantic error: The argument `shift` in `eoshift` must be scalar or have rank one less than `array`
   --> tests/errors/continue_compilation_1.f90:659:22
    |
659 |     b1 = eoshift(b1, eoshift_bad_shift)
    |                      ^^^^^^^^^^^^^^^^^ 

semantic error: No matching `operator(-)` found for this operand type
   --> tests/errors/continue_compilation_1.f90:665:18
    |
665 |         print *, -tt
    |                  ^^^ 

semantic error: Variable 'k' is not declared
   --> tests/errors/continue_compilation_1.f90:681:12
    |
681 |         do k = 1, 3
    |            ^ 'k' is undeclared

semantic error: Expected logical expression in if statement, but recieved logical[:] instead
   --> tests/errors/continue_compilation_1.f90:692:13
    |
692 |         if (abs(arr1)(1) /= 2471095) error stop
    |             ^^^^^^^^^^^^^^^^^^^^^^^ logical[:] expression, expected logical

semantic error: Character intrinsic 'len' with class(*) argument must be inside 'type is (character(len=*))' guard
   --> tests/errors/continue_compilation_1.f90:700:22
    |
700 |         print *, len(generic)
    |                      ^^^^^^^ invalid use of character intrinsic with polymorphic argument

semantic error: Argument of 'len' intrinsic must be CHARACTER, found integer instead.
   --> tests/errors/continue_compilation_1.f90:701:22
    |
701 |         print *, len(a)
    |                      ^ 

semantic error: `unit` must be of type Integer or Character
   --> tests/errors/continue_compilation_1.f90:707:9
    |
707 |         write(unit=r, fmt=*) "hello"  ! {Error} `unit` must be of type Integer or Character
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Type mismatch in assignment, the types must be compatible
   --> tests/errors/continue_compilation_1.f90:713:9
    |
713 |         x = [character(len=3) :: "aa", "bb", "aa"]
    |         ^   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type mismatch (integer[:] and string[:])

semantic error: case value must be scalar
   --> tests/errors/continue_compilation_1.f90:745:16
    |
745 |         case (:[2])
    |                ^^^ 

semantic error: Alternate return arguments are not permitted in calls to the 'cpu_time' intrinsic.
   --> tests/errors/continue_compilation_1.f90:753:9
    |
753 |         call cpu_time(*1)
    |         ^^^^^^^^^^^^^^^^^ 

semantic error: `stat` argument of `sync all` must be of type integer, found string
   --> tests/errors/continue_compilation_1.f90:759:9
    |
759 |         sync all (stat=cstat)  ! {Error} `stat` argument of `sync all` must be of type integer
    |         ^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `errmsg` argument of `sync all` must be of type character, found integer
   --> tests/errors/continue_compilation_1.f90:764:9
    |
764 |         sync all (errmsg=imsg)  ! {Error} `errmsg` argument of `sync all` must be of type character
    |         ^^^^^^^^^^^^^^^^^^^^^^ 

semantic error: `stat` argument of `sync all` must be scalar
   --> tests/errors/continue_compilation_1.f90:769:9
    |
769 |         sync all (stat=astat)  ! {Error} `stat` argument of `sync all` must be scalar
    |         ^^^^^^^^^^^^^^^^^^^^^ 

semantic error: Variable 'nosuch' is not declared
   --> tests/errors/continue_compilation_1.f90:773:9
    |
773 |         sync all (stat=nosuch)  ! {Error} Variable 'nosuch' is not declared
    |         ^^^^^^^^^^^^^^^^^^^^^^ 'nosuch' is undeclared

semantic error: actual argument for 'x' cannot be an assumed-size array
   --> tests/errors/continue_compilation_1.f90:777:23
    |
777 |         call ptr_sink(x)  ! {Error} actual argument for 'x' cannot be an assumed-size array
    |                       ^ 

semantic error: select case expression must be of type integer, character, or logical
   --> tests/errors/continue_compilation_1.f90:785:22
    |
785 |         select case (nn)
    |                      ^^ 

semantic error: select case expression must be of type integer, character, or logical
   --> tests/errors/continue_compilation_1.f90:792:22
    |
792 |         select case (x)
    |                      ^ 

semantic error: second argument of `lge` must have kind equal to 1
   --> tests/errors/continue_compilation_1.f90:800:18
    |
800 |         print *, lge("a", glyph)  
    |                  ^^^^^^^^^^^^^^^ 

semantic error: second argument of `lgt` must have kind equal to 1
   --> tests/errors/continue_compilation_1.f90:801:18
    |
801 |         print *, lgt("a", glyph)  
    |                  ^^^^^^^^^^^^^^^ 

semantic error: first argument of `lle` must have kind equal to 1
   --> tests/errors/continue_compilation_1.f90:802:18
    |
802 |         print *, lle(glyph, "z")  
    |                  ^^^^^^^^^^^^^^^ 

semantic error: first argument of `llt` must have kind equal to 1
   --> tests/errors/continue_compilation_1.f90:803:18
    |
803 |         print *, llt(glyph, "z")  
    |                  ^^^^^^^^^^^^^^^ 

semantic error: Dimension index 5 is out of range for `spread`; expected 1 <= dim <= 2
   --> tests/errors/continue_compilation_1.f90:818:28
    |
818 |         print *, spread(a, 5, 2)
    |                            ^ 

semantic error: Type and kind of the relevant arguments of Merge must be the same
   --> tests/errors/continue_compilation_1.f90:827:18
    |
827 |         print *, merge(a, b, .true.)
    |                  ^^^^^^^^^^^^^^^^^^^ 

semantic error: `a` argument of `co_max` must be of integer, real or character type, but got complex
   --> tests/errors/continue_compilation_1.f90:833:21
    |
833 |         call co_max(z)
    |                     ^ must be integer, real or character type

semantic error: `a` argument of `co_sum` must be of integer, real or complex type, but got logical
   --> tests/errors/continue_compilation_1.f90:839:21
    |
839 |         call co_sum(mask)
    |                     ^^^^ must be integer, real or complex type

semantic error: duplicate statement label 1000
   --> tests/errors/continue_compilation_1.f90:844:9
    |
844 | 1000    continue
    |         ^^^^^^^^ 

semantic error: Selector shall be polymorphic in SELECT TYPE statement
   --> tests/errors/continue_compilation_1.f90:850:22
    |
850 |         select type (a)
    |                      ^ 

semantic error: The `MIN` intrinsic requires all CHARACTER arguments to have the same kind; found kind 1 and 4
   --> tests/errors/continue_compilation_1.f90:859:18
    |
859 |         print *, min(c1, c4)
    |                  ^^^^^^^^^^^ 

semantic error: Label 20 is not defined
   --> tests/errors/continue_compilation_1.f90:864:9
    |
864 |         goto 20  ! {Error} Label 20 is not defined
    |         ^^^^^^^ 

semantic error: actual argument for 'items' cannot be an assumed-size array
   --> tests/errors/continue_compilation_1.f90:875:36
    |
875 |         call consume_assumed_shape(items)  ! {Error} actual argument for 'items' cannot be an assumed-size array
    |                                    ^^^^^ 

semantic error: actual argument for 'items' cannot be an assumed-size array
   --> tests/errors/continue_compilation_1.f90:884:49
    |
884 |         print *, consume_assumed_shape_function(items)  ! {Error} actual argument for 'items' cannot be an assumed-size array
    |                                                 ^^^^^ 

semantic error: Association target cannot be a BOZ literal constant
   --> tests/errors/continue_compilation_1.f90:892:25
    |
892 |         associate (y => z'1') 
    |                         ^^^^ 

semantic error: Cannot initialize integer(4) variable with character(len=3) value in DATA statement
   --> tests/errors/continue_compilation_1.f90:899:9
    |
899 |         data x / "abc" /
    |         ^^^^^^^^^^^^^^^^ 

semantic error: `array` argument of `norm2` intrinsic must be an array
   --> tests/errors/continue_compilation_1.f90:903:19
    |
903 |         x = norm2(1.0)
    |                   ^^^ 

semantic error: `array` argument of `norm2` intrinsic must be real
   --> tests/errors/continue_compilation_1.f90:904:19
    |
904 |         x = norm2([1, 2])
    |                   ^^^^^^ 

semantic error: `dim` argument of `norm2` intrinsic is not a valid dimension index
   --> tests/errors/continue_compilation_1.f90:905:35
    |
905 |         x = norm2([1.0, 2.0], dim=2)
    |                                   ^ 
