Reason V4 [Stacked Diff 3/n #2614] [Parse Hashtags for polymorphic va…

…riants]

Summary:

Implements parsing for "hashtags" polymorphic variant constructors.
Since Reason Syntax still supports object syntax, we needed to rearrange
some syntactic real estate to make this work.

```reason
let red = #FF000;

let isRed = color => switch(color) {
  | #FF0000 => true
  | _ => false
};

let callAMethod = someObject::methodName(isRed, "testing red");

let templateLiteral = `
  String template literals are still using backticks.
  String template literals are still using backticks.
`;

```

Test Plan:

Reviewers:

CC:

formatTest/typeCheckedTests/expected_output/autoUpgradeAngleBrackets.re

@@ -0,0 +1,14 @@
+/**
+ * Even if you have an explicit v3.6 marker.
+ * This whole file wil be auto-upaded to 3.8 becase something uses
+ * angle brackets.
+ */;
+[@reason.version 3.8];
+let watchThisIsOldStyle: list<int> = [1, 2];
+
+let watchThisIsOldStylePoly = #hello;
+
+/**
+ * This will cause the whole file to be promoted.
+ */
+let x: list<int> = [1, 3];

formatTest/typeCheckedTests/expected_output/autoUpgradeAngleBracketsNoVersionAttr.re

@@ -0,0 +1,13 @@
+[@reason.version 3.8];
+/**
+ * Test auto-promotion based on feature inference even if no version
+ * tag. By default you're using the old 3.7.
+ */
+let watchThisIsOldStyle: list<int> = [1, 2];
+
+let watchThisIsOldStylePoly = #hello;
+
+/**
+ * This will cause the whole file to be promoted.
+ */
+let x: list<int> = [1, 3];

formatTest/typeCheckedTests/expected_output/autoUpgradeDoNotAutoUpgrade.re

@@ -0,0 +1,5 @@
+[@reason.version 3.7];
+/**
+ * This should just print a 3.7 version attr at the top.
+ */
+let watchThisIsOldStyle: list(int) = [1, 2];

formatTest/typeCheckedTests/expected_output/oo_3_dot_8.re

@@ -2,13 +2,36 @@
 
 [@reason.version 3.8];
 
+type canStillDefineConst =
+ | []
+ | ::(int, canStillDefineConst);
+
 class virtual stack <'a> (init) = {
+ as self;
  /*
  * The "as this" is implicit and will be formatted away.
  */
  val virtual dummy: unit;
  val mutable v: list<'a> = init;
  pub virtual implementMe: int => int;
+ pub is_empty = () =>
+ switch (v) {
+ | [] => true
+ | _ => false
+ };
+ pub is_empty_unitless =
+ switch (v) {
+ | [] => true
+ | _ => false
+ };
+ pub empty_unitless = {
+ v = [];
+ self;
+ };
+ pub empty = () => {
+ v = [];
+ self;
+ };
  pub pop =
  switch (v) {
  | [hd, ...tl] =>
@@ -90,6 +113,15 @@ class extendedStackAcknowledgeOverride
 
 let inst = (new extendedStack)([1, 2]);
 
+let wasItFull =
+ !inst::empty()::empty_unitless::is_empty();
+// this is the same
+let wasItFull' =
+ !inst::empty()::empty_unitless::is_empty();
+
+let orig_not = (!);
+let (!) = o => o::empty();
+
 /**
  * Recursive classes.
  */
@@ -195,7 +227,7 @@ let acceptsOpenAnonObjAsArg =
  y: int,
  },
  ) =>
- o#x + o#y;
+ o::x + o::y;
 let acceptsClosedAnonObjAsArg =
  (
  o: {
@@ -204,7 +236,7 @@ let acceptsClosedAnonObjAsArg =
  y: int,
  },
  ) =>
- o#x + o#y;
+ o::x + o::y;
 let res =
  acceptsOpenAnonObjAsArg({
  pub x = 0;
@@ -346,13 +378,13 @@ let x: tupleClass<int, int> = {
  pub pr = (10, 10)
 };
 
-let x: #tupleClass<int, int> = x;
+let x: *tupleClass<int, int> = x;
 
 let incrementMyClassInstance:
- (int, #tupleClass<int, int>) =>
- #tupleClass<int, int> =
+ (int, *tupleClass<int, int>) =>
+ *tupleClass<int, int> =
  (i, inst) => {
- let (x, y) = inst#pr;
+ let (x, y) = inst::pr;
  {pub pr = (x + i, y + i)};
  };
 
@@ -361,7 +393,7 @@ class myClassWithNoTypeParams = {};
  * The #myClassWithNoTypeParams should be treated as "simple"
  */
 type optionalMyClassSubtype<'a> =
- option<#myClassWithNoTypeParams> as 'a;
+ option<*myClassWithNoTypeParams> as 'a;
 
 /**
  * Remember, "class type" is really "class_instance_type" (which is the type of
@@ -398,7 +430,7 @@ class addablePoint:
  one: addablePointClassType,
  two: addablePointClassType,
  ) =>
- one#x + two#x + one#y + two#x;
+ one::x + two::x + one::y + two::x;
  pub x: int = init;
  pub y = init;
  };
@@ -412,7 +444,7 @@ class addablePoint2:
  one: addablePointClassType,
  two: addablePointClassType,
  ) =>
- one#x + two#x + one#y + two#x;
+ one::x + two::x + one::y + two::x;
  pub x: int = init;
  pub y = init;
  };

formatTest/typeCheckedTests/expected_output/typeParameters.re

@@ -1,29 +1,29 @@
 /**
  * Testing type parameters.
  */;
-[@reason.version 3.7];
+[@reason.version 3.8];
 
-type threeThings('t) = ('t, 't, 't);
-type listOf('t) = list('t);
+type threeThings<'t> = ('t, 't, 't);
+type listOf<'t> = list<'t>;
 
-type underscoreParam(_) =
+type underscoreParam<_> =
  | Underscored;
-type underscoreParamCovariance(+_) =
+type underscoreParamCovariance<+_> =
  | Underscored;
-type underscoreParamContravariance(-_) =
+type underscoreParamContravariance<-_> =
  | Underscored;
 
-type tickParamCovariance(+'a) =
+type tickParamCovariance<+'a> =
  | Underscored;
-type tickParamContravariance(-'a) =
+type tickParamContravariance<-'a> =
  | Underscored;
 
-let x: option(list('a)) = None;
-type myFunctionType('a) = (
- list(('a, 'a)),
- int => option(list('a)),
+let x: option<list<'a>> = None;
+type myFunctionType<'a> = (
+ list<('a, 'a)>,
+ int => option<list<'a>>,
 );
-let funcAnnoted = (~a: list(int)=[0, 1], ()) => a;
+let funcAnnoted = (~a: list<int>=[0, 1], ()) => a;
 
 /**
  * Syntax that would be likely to conflict with lexing parsing of < > syntax.
@@ -46,12 +46,12 @@ let isSuperGreaterThanEqNegFive3 = zero >>= (-5);
 
 let jsx = (~children, ()) => 0;
 
-type t('a) = 'a;
-let optionArg = (~arg: option(t(int))=?, ()) => arg;
+type t<'a> = 'a;
+let optionArg = (~arg: option<t<int>>=?, ()) => arg;
 let optionArgList =
- (~arg: option(list(list(int)))=?, ()) => arg;
-let defaultJsxArg = (~arg: t(int)=<jsx />, ()) => arg;
-let defaultFalse = (~arg: t(bool)=!true, ()) => arg;
+ (~arg: option<list<list<int>>>=?, ()) => arg;
+let defaultJsxArg = (~arg: t<int>=<jsx />, ()) => arg;
+let defaultFalse = (~arg: t<bool>=!true, ()) => arg;
 /* Doesn't work on master either let defaultTrue = (~arg:t<bool>= !!true) => arg; */
 
 /**

formatTest/typeCheckedTests/input/autoUpgradeAngleBrackets.re

@@ -0,0 +1,14 @@
+/**
+ * Even if you have an explicit v3.6 marker.
+ * This whole file wil be auto-upaded to 3.8 becase something uses
+ * angle brackets.
+ */
+[@reason.version 3.6];
+let watchThisIsOldStyle : list(int) = [1, 2];
+
+let watchThisIsOldStylePoly = `hello;
+
+/**
+ * This will cause the whole file to be promoted.
+ */
+let x : list<int> = [1, 3];

formatTest/typeCheckedTests/input/autoUpgradeAngleBracketsNoVersionAttr.re

@@ -0,0 +1,12 @@
+/**
+ * Test auto-promotion based on feature inference even if no version
+ * tag. By default you're using the old 3.7.
+ */
+let watchThisIsOldStyle : list(int) = [1, 2];
+
+let watchThisIsOldStylePoly = `hello;
+
+/**
+ * This will cause the whole file to be promoted.
+ */
+let x : list<int> = [1, 3];

formatTest/typeCheckedTests/input/autoUpgradeDoNotAutoUpgrade.re

@@ -0,0 +1,5 @@
+/**
+ * This should just print a 3.7 version attr at the top.
+ */
+let watchThisIsOldStyle : list(int) = [1, 2];
+

formatTest/typeCheckedTests/input/oo_3_dot_8.re

@@ -2,13 +2,36 @@
 
 [@reason.version 3.8];
 
+type canStillDefineConst =
+ | []
+ | :: (int, canStillDefineConst);
+
 class virtual stack('a) (init) = {
+ as self;
  /*
  * The "as this" is implicit and will be formatted away.
  */
  val virtual dummy: unit;
  val mutable v: list<'a> = init;
  pub virtual implementMe: int => int;
+ pub is_empty = () =>
+ switch (v) {
+ | [] => true
+ | _ => false
+ };
+ pub is_empty_unitless =
+ switch (v) {
+ | [] => true
+ | _ => false
+ };
+ pub empty_unitless = {
+ v = [];
+ self
+ };
+ pub empty = () => {
+ v = [];
+ self;
+ };
  pub pop =
  switch (v) {
  | [hd, ...tl] =>
@@ -90,6 +113,15 @@ class extendedStackAcknowledgeOverride
 
 let inst = (new extendedStack)([1, 2]);
 
+let wasItFull = !inst::empty()::empty_unitless::is_empty();
+// this is the same
+let wasItFull' = !(inst::empty()::empty_unitless::is_empty());
+
+let orig_not = (!);
+let (!) = o => o::empty();
+
+
+
 /**
  * Recursive classes.
  */
@@ -195,7 +227,7 @@ let acceptsOpenAnonObjAsArg =
  y: int,
  },
  ) =>
- o#x + o#y;
+ o::x + o::y;
 let acceptsClosedAnonObjAsArg =
  (
  o: {
@@ -204,7 +236,7 @@ let acceptsClosedAnonObjAsArg =
  y: int,
  },
  ) =>
- o#x + o#y;
+ o::x + o::y;
 let res =
  acceptsOpenAnonObjAsArg({
  pub x = 0;
@@ -346,13 +378,13 @@ let x: tupleClass<int, int> = {
  pub pr = (10, 10)
 };
 
-let x: #tupleClass<int, int> = x;
+let x: *tupleClass<int, int> = x;
 
 let incrementMyClassInstance:
- (int, #tupleClass<int, int>) =>
- #tupleClass<int, int> =
+ (int, *tupleClass<int, int>) =>
+ *tupleClass<int, int> =
  (i, inst) => {
- let (x, y) = inst#pr;
+ let (x, y) = inst::pr;
  {pub pr = (x + i, y + i)};
  };
 
@@ -361,7 +393,7 @@ class myClassWithNoTypeParams = {};
  * The #myClassWithNoTypeParams should be treated as "simple"
  */
 type optionalMyClassSubtype<'a> =
- option< #myClassWithNoTypeParams> as 'a;
+ option< *myClassWithNoTypeParams> as 'a;
 
 /**
  * Remember, "class type" is really "class_instance_type" (which is the type of
@@ -398,7 +430,7 @@ class addablePoint:
  one: addablePointClassType,
  two: addablePointClassType,
  ) =>
- one#x + two#x + one#y + two#x;
+ one::x + two::x + one::y + two::x;
  pub x: int = init;
  pub y = init;
  };
@@ -412,7 +444,7 @@ class addablePoint2:
  one: addablePointClassType,
  two: addablePointClassType,
  ) =>
- one#x + two#x + one#y + two#x;
+ one::x + two::x + one::y + two::x;
  pub x: int = init;
  pub y = init;
  };

formatTest/unit_tests/expected_output/class_types.re

@@ -37,3 +37,15 @@ class type t = {
 class type t = {
  open M;
 };
+
+class intTuplesTuples =
+ class tupleClass(
+ #tupleClass(int, int),
+ #tupleClass(int, int),
+ );
+
+class intTuplesTuples =
+ class tupleClass(
+ #tupleClass(int, int),
+ #tupleClass(int, int),
+ );

formatTest/unit_tests/expected_output/class_types_3_dot_8.re

@@ -10,7 +10,7 @@ class type bzz = {
 
 class type t = {
  as 'a;
- constraint 'a = #s;
+ constraint 'a = *s;
 };
 
 /* https://github.com/facebook/reason/issues/2037 */