Add boxes to workaround LLVM bug (?) and improve compile time

Summary:
Today in "sacrificing readability / safety due to Rust inefficiencies":

I believe some of our compile times are due to (less severe than in example there) version of this bug: rust-lang/rust#66617

Adding box in a key place happens to circumvent it.

Reviewed By: shiqicao

Differential Revision: D18772104

fbshipit-source-id: a94271b208894aecd9bb8ee1f35110b3c0b09961

Author: dabek

hphp/hack/src/parser/positioned_syntax.rs

@@ -13,15 +13,18 @@ use crate::{
 use ocamlrep::rc::RcOc;
 use oxidized::pos::Pos;
 
+#[derive(Debug, Clone)]
+pub struct Span {
+    pub left: PositionedToken,
+    pub right: PositionedToken,
+}
+
 #[derive(Debug, Clone)]
 pub enum PositionedValue {
     /// value for a token node is token itself
     TokenValue(PositionedToken),
     /// value for a range denoted by pair of tokens
-    TokenSpan {
-        left: PositionedToken,
-        right: PositionedToken,
-    },
+    TokenSpan(Box<Span>),
     Missing {
         offset: usize,
     },
@@ -31,17 +34,19 @@ impl PositionedValue {
     pub fn width(&self) -> usize {
         match self {
             PositionedValue::TokenValue(t) => t.width(),
-            PositionedValue::TokenSpan { left, right } => {
-                (right.end_offset() - left.start_offset()) + 1
-            }
+            PositionedValue::TokenSpan(x) => (x.right.end_offset() - x.left.start_offset()) + 1,
             PositionedValue::Missing { .. } => 0,
         }
     }
 
     fn start_offset(&self) -> usize {
         use PositionedValue::*;
         match &self {
-            TokenValue(t) | TokenSpan { left: t, .. } => t
+            TokenValue(t) => t
+                .leading_start_offset()
+                .expect("invariant violation for Positioned Syntax"),
+            TokenSpan(x) => x
+                .left
                 .leading_start_offset()
                 .expect("invariant violation for Positioned Syntax"),
             Missing { offset, .. } => *offset,
@@ -51,33 +56,55 @@ impl PositionedValue {
     fn leading_width(&self) -> usize {
         use PositionedValue::*;
         match self {
-            TokenValue(t) | TokenSpan { left: t, .. } => t.leading_width(),
+            TokenValue(t) => t.leading_width(),
+            TokenSpan(x) => x.left.leading_width(),
             Missing { .. } => 0,
         }
     }
 
     fn trailing_width(&self) -> usize {
         use PositionedValue::*;
         match self {
-            TokenValue(t) | TokenSpan { right: t, .. } => t.trailing_width(),
+            TokenValue(t) => t.trailing_width(),
+            TokenSpan(x) => x.right.trailing_width(),
             Missing { .. } => 0,
         }
     }
 
+    fn leading_token(&self) -> Option<&PositionedToken> {
+        use PositionedValue::*;
+        match self {
+            TokenValue(l) => Some(&l),
+            TokenSpan(x) => Some(&x.left),
+            _ => None,
+        }
+    }
+
+    fn trailing_token(&self) -> Option<&PositionedToken> {
+        use PositionedValue::*;
+        match self {
+            TokenValue(r) => Some(&r),
+            TokenSpan(x) => Some(&x.right),
+            _ => None,
+        }
+    }
+
     fn value_from_outer_children(first: &Self, last: &Self) -> Self {
         use PositionedValue::*;
         match (first, last) {
-            (TokenValue(l), TokenValue(r))
-            | (TokenSpan { left: l, .. }, TokenValue(r))
-            | (TokenValue(l), TokenSpan { right: r, .. })
-            | (TokenSpan { left: l, .. }, TokenSpan { right: r, .. }) => {
+            (TokenValue(_), TokenValue(_))
+            | (TokenSpan(_), TokenValue(_))
+            | (TokenValue(_), TokenSpan(_))
+            | (TokenSpan(_), TokenSpan(_)) => {
+                let l = first.leading_token().unwrap();
+                let r = last.trailing_token().unwrap();
                 if RcOc::ptr_eq(&l, &r) {
                     TokenValue(RcOc::clone(&l))
                 } else {
-                    TokenSpan {
+                    TokenSpan(Box::new(Span {
                         left: RcOc::clone(&l),
                         right: RcOc::clone(&r),
-                    }
+                    }))
                 }
             }
             // can have two missing nodes if first and last child nodes of

hphp/hack/src/parser/rust_to_ocaml.rs

@@ -247,9 +247,9 @@ impl ToOcaml for PositionedValue {
                 caml_set_field(block, 0, token);
                 block
             }
-            PositionedValue::TokenSpan { left, right } => {
-                let left = left.to_ocaml(context);
-                let right = right.to_ocaml(context);
+            PositionedValue::TokenSpan(x) => {
+                let left = x.left.to_ocaml(context);
+                let right = x.right.to_ocaml(context);
                 // TokenSpan { left: Token.t; right: Token.t }
                 let block = reserve_block(TOKEN_SPAN_VARIANT.into(), 2);
                 caml_set_field(block, 0, left);