RFR: JDK-8027711: Unify wildcarding syntax for CompileCommand and CompileOnly

[Tobias Holenstein]

At the moment `CompileCommand` and `CompileOnly` use different syntax for matching methods. 

### Old CompileOnly format
- matching a **method name** with **class name** and **package name**:
`-XX:CompileOnly=package/path/Class.method`
`-XX:CompileOnly=package/path/Class::method`
`-XX:CompileOnly=package.path.Class::method`
BUT NOT `-XX:CompileOnly=package.path.Class.method`

- just matching a **single method name**:
`-XX:CompileOnly=.hashCode`
`-XX:CompileOnly=::hashCode`
BUT NOT `-XX:CompileOnly=hashCode`

- Matching **all method names** in a **class name** with **package name**
`-XX:CompileOnly=java/lang/String`
BUT NOT `-XX:CompileOnly=java/lang/String.`
BUT NOT `-XX:CompileOnly=java.lang.String`
BUT NOT `-XX:CompileOnly=java.lang.String::` (This is actually a bug) 
BUT NOT `-XX:CompileOnly=String`
BUT NOT `-XX:CompileOnly=String.`
BUT NOT `-XX:CompileOnly=String::`

- Matching **all method names** in a **class name** with **NO package name**
`-XX:CompileOnly=String`
BUT NOT `-XX:CompileOnly=String.`
BUT NOT `-XX:CompileOnly=String::`

- There is a bug when `CompileOnly` ends with `::` where the `CompileOnly` is just ignored
e.g. `-XX:CompileOnly=String::` compiles as many methods as when omitting the `-XX:CompileOnly=` command

### CompileCommand=compileonly format
`CompileCommand` allows two different forms for paths: 
- `package/path/Class.method`
- `package.path.Class::method`

In contrary to `CompileOnly` `CompileCommand` supports wildcard matching using `*`. `*` can appear at the beginning and/or end of a `package.path.Class` and `method` name. 

 Valid forms: 
`-XX:CompileCommand=compileonly,*.lang.*::*shCo*`
`-XX:CompileCommand=compileonly,*/lang/*.*shCo*` 
`-XX:CompileCommand=compileonly,java.lang.String::*`
`-XX:CompileCommand=compileonly,*::hashCode`
`-XX:CompileCommand=compileonly,*ng.String::hashC*`
`-XX:CompileCommand=compileonly,*String::hash*`

 Invalid forms (Error: Embedded * not allowed):
 `-XX:CompileCommand=compileonly,java.*.String::has*Code`

### Use CompileCommand syntax for CompileOnly
At the moment, in some cases it is not possible to just take pattern used with `CompileOnly` and plug it into compile command file. Syntax used by CompileOnly is also not very intuitive. 

`CompileOnly` is convenient because it's shorter to write and takes lists of patterns, whereas `CompileCommand` only takes one pattern per command. 

With this PR `CompileOnly` becomes an alias for `CompileCommand=compileonly` with possibility to take lists as input. 

New syntax for `CompileOnly`:
- `-XX:CompileOnly=pattern1,pattern2`
is an **alias** for: 
- `-XX:CompileCommand=compileonly,pattern1 -XX:CompileCommand=compileonly,pattern2`

### Handling invalid syntax
Before `CompileOnly` just ignored invalid syntax. `CompileCommand` at least prints an error massage for invalid patterns:

CompileOnly: An error occurred during parsing
Error: Could not parse method pattern
Line: 'pattern'

Since `CompileOnly` now maps to `CompileCommand` is also prints the error message for invalid inputs. 
In the future `CompileCommand` (and `CompileOnly`) parsing errors could exit the VM https://bugs.openjdk.org/browse/JDK-8282797

### Changed test cases
In the following we mean with `-XX:CompileOnly=oldPattern` -> `-XX:CompileOnly=newPattern` that we changed the tests from the `oldPattern` to the `newPattern`:
- `Class.method` -> `Class::method` AND `package/path/Class.method` -> `package.path.Class::method`
Prefer the `package.path.Class::method` format because it is used by `-XX:+PrintCompilation`

- `Class` -> `Class::*`
The `CompileCommand` format requires the `::` to define if `Class` is a class name or a method name. 

- `::method` -> `*::method`
The `CompileCommand` format requires the `*`(wildcard) if no class name is given. 

- `package/path/Class` -> `package.path.Class::*`
The `CompileCommand` format requires the `*`(wildcard) if no method name is given. 
Prefer the `package.path.Class::method` format because it is used by `-XX:+PrintCompilation`

- `::get,::get1` -> `*Class::get*`
The `CompileCommand` format requires the `*`(wildcard) if no method name is given. Therefore `*::get` would work as well, but this matches many other methods as well like `java.util.HashMap::get`.
`*Class::get,*Class::get1` matches the wanted class name - `*Class::get*` is just the short form. 

- `package/path/Class::method` -> `package.path.Class::method`
The old format of `CompileOnly` combining `/` with `::`. 
The `CompileCommand` is either `package/path/Class.method` or `package.path.Class::method`. 

- _BUG_: `package.path.Class::` -> `package.path.Class::*`
There was a bug in the old format of `CompileOnly` : when the pattern ended with `::` the `CompileOnly` was just ignored and all methods compiled. The `CompileCommand` format requires the `*`(wildcard) if no method name is given.

-------------

Commit messages:
 - Updated copyright
 - fix CompileOnly tests
 - JDK-8027711: Unify wildcarding syntax for CompileCommand and CompileOnly

Changes: https://git.openjdk.org/jdk/pull/13802/files
 Webrev: https://webrevs.openjdk.org/?repo=jdk&pr=13802&range=00
  Issue: https://bugs.openjdk.org/browse/JDK-8027711
  Stats: 376 lines in 71 files changed: 29 ins; 73 del; 274 mod
  Patch: https://git.openjdk.org/jdk/pull/13802.diff
  Fetch: git fetch https://git.openjdk.org/jdk.git pull/13802/head:pull/13802

PR: https://git.openjdk.org/jdk/pull/13802