Compiler option (#535)

* adding solidity versions to options

* visit each PragmaDirective on parse and infer the compiler

* recreate logic for byte and bytes if we are on a compiler that supports them

* adding tests for the scenarios

* not splitting imports if we are in version before 0.7.4

* No need to run eslint with json files

* refactor of solc.json to a leaner array

* reorganising tests to be more descriptive

* dependency updates

* Keeping the documentation for the ImportDirective

* added more documentation on the full system.

* moving tests to new tests/format folder

* implementing feedback from Franco
- compiler should not be inferred
- safe formats should be used if no compiler is provided

* spell checking

* Not needed anymore

* addressing feedback

* missing dot

* semver.coerce(options.compiler) is much simpler than having a dedicated util for that

* updating dependencies

* adding documentation for compiler option

* Update src/parser.js

Co-authored-by: Franco Victorio <[email protected]>

* Move the "Explicit Types" option before the "Compiler" one

* Mark the compiler option as experimental and rewrite its description

* Update README.md

Co-authored-by: Franco Victorio <[email protected]>

Author: Janther

.gitignore

@@ -62,6 +62,10 @@ typings/
 
 .DS_Store
 
-# package-lock.json
-
+# yarn 2 config
 yarn.lock
+.yarn
+.yarnrc.yml
+
+# vscode config
+.vscode

CODE_OF_CONDUCT.md

@@ -6,7 +6,7 @@ In the interest of fostering an open and welcoming environment, we as
 contributors and maintainers pledge to making participation in our project and
 our community a harassment-free experience for everyone, regardless of age, body
 size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
+level of experience, education, socioeconomic status, nationality, personal
 appearance, race, religion, or sexual identity and orientation.
 
 ## Our Standards

README.md

@@ -112,8 +112,95 @@ uint public a;
 int256 public b;
 ```
 
+Note: if the compiler option is provided and is lesser than 0.8.0, explicitTypes will also consider the alias `byte` for the explicit type `bytes1`.
+
 Note: switching between `uint` and `uint256` does not alter the bytecode at all and we have implemented tests for this. However, there will be a change in the AST reflecting the switch.
 
+### Compiler (experimental)
+
+Many versions of the Solidity compiler have changes that affect how the code should be formatted. This plugin, by default, tries to format the code in the most compatible way that it's possible, but you can use the experimental `compiler` option to nudge it in the right direction.
+
+One example of this are import directives. Before `0.7.4`, the compiler didn't accept multi-line import statements, so we always format them in a single line. But if you use the `compiler` option to indicate that you are using a version greater or equal than `0.7.4`, the plugin will use multi-line imports when it makes sense.
+
+The solidity versions taken into consideration during formatting are:
+
+- `v0.7.4`: Versions prior `0.7.4` had a bug that would not interpret correctly imports unless they are formatted in a single line.
+
+  ```Solidity
+  // Input
+  import { Foo as Bar } from "/an/extremely/long/location";
+
+  // "compiler": undefined
+  import { Foo as Bar } from "/an/extremely/long/location";
+
+  // "compiler": "0.7.3" (or lesser)
+  import { Foo as Bar } from "/an/extremely/long/location";
+
+  // "compiler": "0.7.4" (or greater)
+  import {
+      Foo as Bar
+  } from "/an/extremely/long/location";
+  ```
+
+- `v0.8.0`: Introduced these [changes](https://docs.soliditylang.org/en/v0.8.0/080-breaking-changes.html)
+
+  - The type `byte` has been removed. It was an alias of `bytes1`.
+  - Exponentiation is right associative, i.e., the expression `a**b**c` is parsed as `a**(b**c)`. Before 0.8.0, it was parsed as `(a**b)**c`.
+
+  ```Solidity
+  // Input
+  bytes1 public a;
+  byte public b;
+
+  uint public c = 1 ** 2 ** 3;
+
+  // "compiler": undefined
+  // "explicitTypes": "never"
+  bytes1 public a;
+  bytes1 public b;
+
+  uint public c = 1 ** 2 ** 3;
+
+  // "compiler": "0.7.6" (or lesser)
+  // "explicitTypes": "never"
+  byte public a;
+  byte public b;
+
+  uint public c = (1**2)**3;
+
+  // "compiler": "0.8.0" (or greater)
+  // "explicitTypes": "never"
+  bytes1 public a;
+  bytes1 public b;
+
+  uint public c = 1**(2**3);
+  ```
+
+You might have a multi-version project, where different files are compiled with different compilers. If that's the case, you can use [overrides](https://prettier.io/docs/en/configuration.html#configuration-overrides) to have a more granular configuration:
+
+```
+{
+  "overrides": [
+    {
+      "files": "contracts/v1/**/*.sol",
+      "options": {
+        "compiler": "0.6.3"
+      }
+    },
+    {
+      "files": "contracts/v2/**/*.sol",
+      "options": {
+        "compiler": "0.8.4"
+      }
+    }
+  ]
+}
+```
+
+| Default | CLI Override          | API Override           |
+| ------- | --------------------- | ---------------------- |
+| None    | `--compiler <string>` | `compiler: "<string>"` |
+
 ## Integrations
 
 ### Vim