Removes need for matching begin-end scope names

Previously nested scopes had to be closed in the reverse order than they
were opened e.g.

```f90
subroutine scope_1()
  subroutine scope_2()
    subroutine scope_3()
    end subroutine scope_3
  end subroutine scope_2
end subroutine scope_1
```

However with preprocessor conditionals that would be an issue since

```f90
subroutine scope_1()
#ifdef DEF
  subroutine scope_2()
#else
  subroutine scope_3()
#endif

#ifdef DEF
  end subroutine scope_2()
#else
  end subroutine scope_3()
#endif
end subroutine scope_1
```

`scope_2` and `scope_3`  would be in the same level on the AST, so it is
no longer valid to expect `scope_3` to close before `scope_2`.

The solution to this is removing the strict requirement for scopes to
have matching begin-end names from the regex. The type of scopes
where this requirement is removed are:

- Functions
- Modules
- Programs
- Module Procedures
- Subroutines
- Submodules

Fixes Erroneous syntax highlighting with subroutine names and preprocessor conditionals #278

Author: gnikit

syntaxes/fortran_free-form.tmLanguage.json

@@ -4060,7 +4060,7 @@
                   "name": "entity.name.function.fortran"
                 }
               },
-              "end": "(?ix)\\s*\\b(?:(end\\s*function)(?:\\s+(\\1))?|(end))\\b \\s*([^;!\\n]+)?(?=[;!\\n])",
+              "end": "(?ix)\\s*\\b(?:(end\\s*function)(?:\\s+([a-z_]\\w*))?|(end))\\b \\s*([^;!\\n]+)?(?=[;!\\n])",
               "endCaptures": {
                 "1": {
                   "name": "keyword.other.endfunction.fortran"
@@ -4148,7 +4148,7 @@
               "name": "entity.name.class.module.fortran"
             }
           },
-          "end": "(?ix)\\b(?:(end\\s*module)(?:\\s+(\\1))?|(end))\\b \\s*([^;!\\n]+)?(?=[;!\\n])",
+          "end": "(?ix)\\b(?:(end\\s*module)(?:\\s+([a-z_]\\w*))?|(end))\\b \\s*([^;!\\n]+)?(?=[;!\\n])",
           "endCaptures": {
             "1": {
               "name": "keyword.other.endmodule.fortran"
@@ -4218,7 +4218,7 @@
               "name": "entity.name.program.fortran"
             }
           },
-          "end": "(?ix)\\b(?:(end\\s*program)(?:\\s+(\\1))?|(end))\\b\\s*([^;!\\n]+)?(?=[;!\\n])",
+          "end": "(?ix)\\b(?:(end\\s*program)(?:\\s+([a-z_]\\w*))?|(end))\\b\\s*([^;!\\n]+)?(?=[;!\\n])",
           "endCaptures": {
             "1": {
               "name": "keyword.control.endprogram.fortran"
@@ -4289,7 +4289,7 @@
                   "name": "entity.name.function.procedure.fortran"
                 }
               },
-              "end": "(?ix)\\s*\\b(?:(end\\s*procedure)(?:\\s+(\\1))?|(end))\\b \\s*([^;!\\n]+)?(?=[;!\\n])",
+              "end": "(?ix)\\s*\\b(?:(end\\s*procedure)(?:\\s+([a-z_]\\w*))?|(end))\\b \\s*([^;!\\n]+)?(?=[;!\\n])",
               "endCaptures": {
                 "1": {
                   "name": "keyword.other.endprocedure.fortran"
@@ -4395,7 +4395,7 @@
                   "name": "entity.name.function.subroutine.fortran"
                 }
               },
-              "end": "(?ix)\\b(?:(end\\s*subroutine)(?:\\s+(\\1))?|(end))\\b \\s*([^;!\\n]+)?(?=[;!\\n])",
+              "end": "(?ix)\\b(?:(end\\s*subroutine)(?:\\s+([a-z_]\\w*))?|(end))\\b \\s*([^;!\\n]+)?(?=[;!\\n])",
               "endCaptures": {
                 "1": {
                   "name": "keyword.other.endsubroutine.fortran"
@@ -4493,7 +4493,7 @@
               "name": "entity.name.module.submodule.fortran"
             }
           },
-          "end": "(?ix)\\s*\\b(?:(end\\s*submodule)(?:\\s+(\\1))?|(end))\\b \\s*([^;!\\n]+)?(?=[;!\\n])",
+          "end": "(?ix)\\s*\\b(?:(end\\s*submodule)(?:\\s+([a-z_]\\w*))?|(end))\\b \\s*([^;!\\n]+)?(?=[;!\\n])",
           "endCaptures": {
             "1": {
               "name": "keyword.other.endsubmodule.fortran"

test/resources/pp_in_func.f90

@@ -0,0 +1,121 @@
+! Out of order nested function/subroutine definitions such as in the case
+! of preprocessing directives, where the inner scope is not the scope that closes
+! first, yield invalid.error syntax highlighting because we attempt to match
+! the name from the begin REGEX to the end REGEX match i.e. \\1
+! This can be circumvented by matching a word character instead [a-z_]\\w*
+! Obviously this is not going to highlight when the wrong name is used to
+! close a scope, but the linter should solve that
+
+!
+subroutine blasmul_mm()
+   interface
+#ifdef DOUBLEP
+      SUBROUTINE DGEMM ( )
+#else
+      SUBROUTINE SGEMM (  )
+#endif
+
+#ifdef DOUBLEP
+      END SUBROUTINE DGEMM
+#else
+      END SUBROUTINE SGEMM
+#endif
+   end interface
+
+end subroutine blasmul_mm
+
+! This would work with the previous definition of the end REGEX because the scopes
+! close in the order that they open
+subroutine blasmul_mm()
+   interface
+#ifdef DOUBLEP
+      SUBROUTINE DGEMM ( )
+#else
+      SUBROUTINE SGEMM (  )
+#endif
+
+#ifndef DOUBLEP
+      END SUBROUTINE SGEMM
+#else
+      END SUBROUTINE DGEMM
+#endif
+   end interface
+
+end subroutine blasmul_mm
+
+REAL FUNCTION blasmul_mm() RESULT(VAL)
+   interface
+#ifdef DOUBLEP
+      FUNCTION DGEMM ( )
+#else
+      FUNCTION SGEMM (  )
+#endif
+
+#ifdef DOUBLEP
+      END FUNCTION DGEMM
+#else
+      END FUNCTION SGEMM
+#endif
+   end interface
+
+END FUNCTION blasmul_mm
+
+MODULE blasmul_mm
+#ifdef DOUBLEP
+   MODULE DGEMM
+#else
+   MODULE SGEMM
+#endif
+
+#ifdef DOUBLEP
+   END MODULE DGEMM
+#else
+   END MODULE SGEMM
+#endif
+
+end MODULE blasmul_mm
+
+SUBMODULE (name) blasmul_mm
+#ifdef DOUBLEP
+   SUBMODULE (name) DGEMM
+#else
+   SUBMODULE (name) SGEMM
+#endif
+
+#ifdef DOUBLEP
+   END SUBMODULE DGEMM
+#else
+   END SUBMODULE SGEMM
+#endif
+
+end SUBMODULE blasmul_mm
+
+PROGRAM blasmul_mm
+#ifdef DOUBLEP
+   PROGRAM DGEMM
+#else
+   PROGRAM SGEMM
+#endif
+
+#ifdef DOUBLEP
+   END PROGRAM DGEMM
+#else
+   END PROGRAM SGEMM
+#endif
+
+end PROGRAM blasmul_mm
+
+MODULE PROCEDURE blasmul_mm
+#ifdef DOUBLEP
+MODULE PROCEDURE DGEMM
+#else
+MODULE PROCEDURE SGEMM
+#endif
+
+#ifdef DOUBLEP
+END PROCEDURE DGEMM
+#else
+END PROCEDURE SGEMM
+#endif
+
+end PROCEDURE blasmul_mm