[DRAFT] UDT in REPL

src/libraries/Microsoft.PowerFx.Core/Public/DefinitionsCheckResult.cs

@@ -116,6 +116,8 @@ internal ParseUserDefinitionResult ApplyParse()
 
         public bool ContainsUDF => _parse.UDFs.Any();
 
+        public bool ContainsUDT => _parse.DefinedTypes.Any();
+
         internal IReadOnlyDictionary<DName, FormulaType> ApplyResolveTypes()
         {
             if (_parse == null)
@@ -178,7 +180,7 @@ internal TexlFunctionSet ApplyCreateUserDefinedFunctions()
                 foreach (var udf in partialUDFs)
                 {
                     var config = new BindingConfig(allowsSideEffects: _parserOptions.AllowsSideEffects, useThisRecordForRuleScope: false, numberIsFloat: false, userDefinitionsMode: true);
-                    var binding = udf.BindBody(composedSymbols, new Glue2DocumentBinderGlue(), config);
+                    var binding = udf.BindBody(composedSymbols, new Glue2DocumentBinderGlue(), config, features: _features);
 
                     List<TexlError> bindErrors = new List<TexlError>();
 

src/libraries/Microsoft.PowerFx.Core/Public/Types/RecordType.cs

@@ -188,5 +188,10 @@ internal override void DefaultExpressionValue(StringBuilder sb)
 
             sb.Append("}");
         }
+
+        public void SetFieldsOptional()
+        {
+            _type.AreFieldsOptional = true;
+        }
     }
 }

src/libraries/Microsoft.PowerFx.Core/Syntax/Visitors/DTypeVisitor.cs

@@ -84,7 +84,7 @@ public override DType Visit(TableNode node, INameResolver context)
         {
             Contracts.AssertValue(node);
             Contracts.AssertValue(context);
-
+            
             if (node.ChildNodes.Count != 1)
             {
                 return DType.Invalid;

src/libraries/Microsoft.PowerFx.Interpreter/RecalcEngine.cs

@@ -386,6 +386,11 @@ public void UpdateSupportedFunctions(SymbolTable s)
             SupportedFunctions = s;
         }
 
+        public ReadOnlySymbolTable GetAllSymbols()
+        {
+            return SymbolTable.Compose(Config.ComposedConfigSymbols, SupportedFunctions, _symbolTable, PrimitiveTypes);
+        }
+
         /// <summary>
         /// Add a set of user-defined formulas and functions to the engine.
         /// </summary>
@@ -420,7 +425,7 @@ public void AddUserDefinitions(string script, CultureInfo parseCulture = null, A
             }
 
             // Compose will handle null symbols
-            var composedSymbols = SymbolTable.Compose(Config.ComposedConfigSymbols, SupportedFunctions, PrimitiveTypes, _symbolTable);
+            var composedSymbols = SymbolTable.Compose(Config.ComposedConfigSymbols, SupportedFunctions, _symbolTable, PrimitiveTypes);
 
             if (parseResult.DefinedTypes.Any())
             {

src/libraries/Microsoft.PowerFx.Repl/Repl.cs

@@ -508,25 +508,41 @@ await this.Output.WriteLineAsync($"Error: Can't set '{name}' to a Void value.",
                 definitionsCheckResult.SetText(expression, this.ParserOptions)
                     .ApplyParseErrors();
 
-                if (this.AllowUserDefinedFunctions && definitionsCheckResult.IsSuccess && definitionsCheckResult.ContainsUDF)
+                if (definitionsCheckResult.IsSuccess)
                 {
-                    var defCheckResult = this.Engine.AddUserDefinedFunction(expression, this.ParserOptions.Culture, extraSymbolTable);
+                    definitionsCheckResult.SetBindingInfo(this.Engine.GetAllSymbols());
 
-                    if (!defCheckResult.IsSuccess)
+                    if (definitionsCheckResult.ApplyErrors().Any())
                     {
-                        foreach (var error in defCheckResult.Errors)
+                        foreach (var error in definitionsCheckResult.Errors)
                         {
                             var kind = error.IsWarning ? OutputKind.Warning : OutputKind.Error;
                             var msg = error.ToString();
 
                             await this.Output.WriteLineAsync(lineError + msg, kind, cancel)
                                 .ConfigureAwait(false);
                         }
+
+                        return new ReplResult();
                     }
 
+                    this.Engine.AddUserDefinitions(expression, this.ParserOptions.Culture);
+
                     return new ReplResult();
                 }
 
+                if (check.ApplyParse().Errors.Any() && definitionsCheckResult.Errors.Any())
+                {
+                    foreach (var error in definitionsCheckResult.Errors)
+                    {
+                        var kind = error.IsWarning ? OutputKind.Warning : OutputKind.Error;
+                        var msg = error.ToString();
+
+                        await this.Output.WriteLineAsync(lineError + msg, kind, cancel)
+                            .ConfigureAwait(false);
+                    }
+                }
+
                 foreach (var error in check.Errors)
                 {
                     var kind = error.IsWarning ? OutputKind.Warning : OutputKind.Error;

src/tools/Repl/Program.cs

@@ -123,6 +123,16 @@ private static RecalcEngine ReplRecalcEngine()
             config.AddFunction(new Run2Function());
             config.AddFunction(new Language1Function());
 
+            var testRecordType = RecordType.Empty()
+              .Add(new NamedFormulaType("name", FormulaType.String, "Name"))
+              .Add(new NamedFormulaType("age", FormulaType.Number, "Age"));
+
+            testRecordType
+              .SetFieldsOptional();
+
+            config.SymbolTable.AddType(new Core.Utils.DName("TestRecord"), testRecordType);
+            config.SymbolTable.AddType(new Core.Utils.DName("TestTable"), testRecordType.ToTable());
+
             var optionsSet = new OptionSet("Options", DisplayNameUtility.MakeUnique(options));
 
 #if MATCHCOMPARE