ExprCompiledValue::Type

Summary:
A variant of compiled expression which is `type(expr)`.

Used in the following diff D30867542.

Reviewed By: ndmitchell

Differential Revision: D30867363

fbshipit-source-id: b79a146545774b061993467d6b032706f77a6905

Author: stepancheg

starlark/src/eval/fragment/expr.rs

@@ -48,20 +48,26 @@ pub(crate) type ExprCompiled = Box<
 pub(crate) enum ExprCompiledValue {
     Value(FrozenValue),
     Compiled(ExprCompiled),
+    /// `type(x)`
+    Type(ExprCompiled),
 }
 
 impl ExprCompiledValue {
     pub fn as_value(&self) -> Option<FrozenValue> {
         match self {
             Self::Value(x) => Some(*x),
-            Self::Compiled(_) => None,
+            _ => None,
         }
     }
 
     pub fn as_compiled(self) -> ExprCompiled {
         match self {
             Self::Value(x) => box move |_| Ok(x.to_value()),
             Self::Compiled(x) => x,
+            Self::Type(x) => expr!("type", |eval| {
+                x(eval)?.get_ref().get_type_value().to_value()
+            })
+            .as_compiled(),
         }
     }
 }

starlark/src/eval/fragment/known.rs

@@ -22,10 +22,9 @@ use crate::{
     eval::{
         compiler::{scope::CstExpr, Compiler},
         fragment::expr::{ExprCompiled, ExprCompiledValue},
-        Evaluator,
     },
     syntax::ast::ExprP,
-    values::{dict::Dict, list::List, Value},
+    values::{dict::Dict, list::List},
 };
 
 /// Convert a list into a tuple. In many cases (iteration, `in`) these types
@@ -72,11 +71,11 @@ impl Compiler<'_> {
                     Conditional::False
                 }
             }
-            ExprCompiledValue::Compiled(v) => {
+            v => {
                 if expect {
-                    Conditional::Normal(v)
+                    Conditional::Normal(v.as_compiled())
                 } else {
-                    Conditional::Negate(v)
+                    Conditional::Negate(v.as_compiled())
                 }
             }
         }
@@ -99,11 +98,7 @@ impl Compiler<'_> {
         }
         match self.expr(expr) {
             ExprCompiledValue::Value(x) => ExprCompiledValue::Value(x.to_value().get_type_value()),
-            ExprCompiledValue::Compiled(x) => {
-                expr!("type", |eval| {
-                    x(eval)?.get_ref().get_type_value().to_value()
-                })
-            }
+            x => ExprCompiledValue::Type(x.as_compiled()),
         }
     }
 }

starlark/src/eval/fragment/stmt.rs

@@ -435,9 +435,12 @@ impl Compiler<'_> {
     fn stmt_expr_compiled(&mut self, span: Span, expr: ExprCompiledValue) -> StmtsCompiled {
         match expr {
             ExprCompiledValue::Value(_) => StmtsCompiled::empty(),
-            ExprCompiledValue::Compiled(e) => stmt!(self, "expr", span, |eval| {
-                e(eval)?;
-            }),
+            e => {
+                let e = e.as_compiled();
+                stmt!(self, "expr", span, |eval| {
+                    e(eval)?;
+                })
+            }
         }
     }