Merge branch 'main' into adithyase/customtypes

releasenotes/releasenotes-1.3.0-rc.md

@@ -0,0 +1,8 @@
+# Changes for 1.3.0 [RC]
+
+## Breaking Language changes:
+
+
+## New API features
+
+## Other:

src/libraries/Microsoft.PowerFx.Connectors/Microsoft.PowerFx.Connectors.csproj

@@ -4,7 +4,7 @@
     <Version Condition=" '$(ReleasePackageVersion)' != '' ">$(ReleasePackageVersion)</Version>
     <PackageVersion Condition=" '$(ReleasePackageVersion)' == '' ">$(LocalPackageVersion)</PackageVersion>
     <PackageVersion Condition=" '$(ReleasePackageVersion)' != '' ">$(ReleasePackageVersion)</PackageVersion>
-    <Configurations>Debug;Release</Configurations>
+    <Configurations>Debug;Release</Configurations>    
   </PropertyGroup>
 
   <!-- Nuget Properties -->

src/libraries/Microsoft.PowerFx.Connectors/OpenApiExtensions.cs

@@ -407,7 +407,7 @@ internal static ConnectorType GetConnectorType(this OpenApiParameter openApiPara
                 case "string":
 
                     // We don't want to have OptionSets in connections, we'll only get string/number for now in FormulaType
-                    // Anyhow, we'll have schema.Enum content in ConnertorType
+                    // Anyhow, we'll have schema.Enum content in ConnectorType
 
                     switch (schema.Format)
                     {
@@ -428,8 +428,8 @@ internal static ConnectorType GetConnectorType(this OpenApiParameter openApiPara
                         case "enum":
                             if (schema.Enum.All(e => e is OpenApiString))
                             {
-                                OptionSet os = new OptionSet("enum", schema.Enum.Select(e => new DName((e as OpenApiString).Value)).ToDictionary(k => k, e => e).ToImmutableDictionary());
-                                return new ConnectorType(schema, openApiParameter, os.FormulaType);
+                                OptionSet optionSet = new OptionSet("enum", schema.Enum.Select(e => new DName((e as OpenApiString).Value)).ToDictionary(k => k, e => e).ToImmutableDictionary());
+                                return new ConnectorType(schema, openApiParameter, optionSet.FormulaType);
                             }
                             else
                             {

src/libraries/Microsoft.PowerFx.Connectors/Public/ConnectorType.cs

@@ -45,29 +45,39 @@ public class ConnectorType : SupportsConnectorErrors
         // "x-ms-explicit-input"
         public bool ExplicitInput { get; }
 
-        // "enum" 
         public bool IsEnum { get; }
 
         // Enumeration value, only defined if IsEnum is true
         public FormulaValue[] EnumValues { get; }
 
         // Enumeration display name ("x-ms-enum-display-name"), only defined if IsEnum is true
-        // If not defined, this array will be empty
+        // If not defined, this array will be empty 
         public string[] EnumDisplayNames { get; }
 
-        // Option Set, only defined when IsEnum is true and EnumValues is not empty
-        public OptionSet OptionSet => GetOptionSet();
+        public Dictionary<string, FormulaValue> Enum => GetEnum();
 
-        public Visibility Visibility { get; internal set; }  
+        public Visibility Visibility { get; internal set; }
 
         internal RecordType HiddenRecordType { get; }
 
+        // Supports x-ms-dynamic-values or -list locally
         public bool SupportsDynamicValuesOrList => DynamicValues != null || DynamicList != null;
 
+        // Supports x-ms-dynamic-values or -list locally or anywhere in the tree
+        public bool ContainsDynamicValuesOrList => SupportsDynamicValuesOrList || (Fields != null && Fields.Any(f => f.ContainsDynamicValuesOrList));
+
+        // Supports x-ms-dynamic-schema or -property locally
         public bool SupportsDynamicSchemaOrProperty => DynamicSchema != null || DynamicProperty != null;
 
+        // Supports x-ms-dynamic-schema or -property locally or anywhere in the tree
+        public bool ContainsDynamicSchemaOrProperty => SupportsDynamicSchemaOrProperty || (Fields != null && Fields.Any(f => f.ContainsDynamicSchemaOrProperty));
+
+        // Supports x-ms-dynamic-values, -list, -schema, or -property locally
         public bool SupportsDynamicIntellisense => SupportsDynamicValuesOrList || SupportsDynamicSchemaOrProperty;
 
+        // Supports x-ms-dynamic-values, -list, -schema, or -property locally or anywhere in the tree
+        public bool ContainsDynamicIntellisense => ContainsDynamicValuesOrList || ContainsDynamicSchemaOrProperty;
+
         internal ConnectorDynamicSchema DynamicSchema { get; private set; }
 
         internal ConnectorDynamicProperty DynamicProperty { get; private set; }
@@ -93,7 +103,7 @@ internal ConnectorType(OpenApiSchema schema, OpenApiParameter openApiParameter,
             MediaKind = openApiParameter?.GetMediaKind().ToMediaKind() ?? (Binary ? MediaKind.File : MediaKind.NotBinary);
 
             if (schema != null)
-            {                
+            {
                 Description = schema.Description;
                 DisplayName = schema.GetSummary();
                 ExplicitInput = schema.GetExplicitInput();
@@ -104,22 +114,24 @@ internal ConnectorType(OpenApiSchema schema, OpenApiParameter openApiParameter,
                 if (IsEnum)
                 {
                     EnumValues = schema.Enum.Select(oaa =>
-                    {                        
+                    {
                         if (OpenApiExtensions.TryGetOpenApiValue(oaa, null, out FormulaValue fv, this))
                         {
                             return fv;
                         }
-                        
+
                         AddError($"Invalid conversion for type {oaa.GetType().Name} in enum");
                         return FormulaValue.NewBlank();
                     }).ToArray();
 
+                    // x-ms-enum-display-name
                     EnumDisplayNames = schema.Extensions != null && schema.Extensions.TryGetValue(XMsEnumDisplayName, out IOpenApiExtension enumNames) && enumNames is OpenApiArray oaa
                                         ? oaa.Cast<OpenApiString>().Select(oas => oas.Value).ToArray()
-                                        : Array.Empty<string>();
+                                        : Array.Empty<string>();                                        
                 }
                 else
                 {
+                    // those values are null/empty even if x-ms-dynamic-* could be present and would define possible values
                     EnumValues = Array.Empty<FormulaValue>();
                     EnumDisplayNames = Array.Empty<string>();
                 }
@@ -176,6 +188,33 @@ internal ConnectorType(OpenApiSchema schema, OpenApiParameter openApiParameter,
             AggregateErrors(hiddenFields);
         }
 
+        internal ConnectorType(ConnectorType connectorType, ConnectorType[] fields, FormulaType formulaType)
+        {
+            Binary = connectorType.Binary;
+            Description = connectorType.Description;
+            DisplayName = connectorType.DisplayName;
+            EnumDisplayNames = connectorType.EnumDisplayNames;
+            EnumValues = connectorType.EnumValues;
+            ExplicitInput = connectorType.ExplicitInput;            
+            IsEnum = true;
+            IsRequired = connectorType.IsRequired;
+            MediaKind = connectorType.MediaKind;
+            Name = connectorType.Name;
+            Schema = connectorType.Schema;
+            Visibility = connectorType.Visibility;
+
+            Fields = fields;
+            FormulaType = formulaType;
+
+            DynamicList = null;
+            DynamicProperty = null;
+            DynamicSchema = null;
+            DynamicValues = null;
+
+            _errors = connectorType._errors;
+            _warnings = connectorType._warnings;
+        }
+
         private void AggregateErrors(ConnectorType[] types)
         {
             if (types != null)
@@ -187,14 +226,32 @@ private void AggregateErrors(ConnectorType[] types)
             }
         }
 
-        private OptionSet GetOptionSet()
+        // Keeping code for creating OptionSet if we need it later
+
+        //private OptionSet GetOptionSet()
+        //{
+        //    if (!IsOptionSet || string.IsNullOrEmpty(Name))
+        //    {
+        //        return null;
+        //    }
+
+        //    string[] enumValues = EnumValues.Select(ev => ev.ToObject().ToString()).ToArray();
+        //    string[] enumDisplayNames = EnumDisplayNames ?? enumValues;
+
+        //    return new OptionSet(Name, enumValues.Zip(enumDisplayNames, (ev, dn) => new KeyValuePair<string, string>(ev, dn)).ToDictionary(kvp => new DName(kvp.Key), kvp => new DName(kvp.Value)).ToImmutableDictionary());
+        //}
+
+        private Dictionary<string, FormulaValue> GetEnum()
         {
-            if (!IsEnum || string.IsNullOrEmpty(Name) || EnumValues.Length != EnumDisplayNames.Length)
+            if (!IsEnum || string.IsNullOrEmpty(Name))
             {
                 return null;
             }
 
-            return new OptionSet(Name, EnumValues.Select(ev => ev.ToObject().ToString()).Zip(EnumDisplayNames, (ev, dn) => new KeyValuePair<string, string>(ev, dn)).ToDictionary(kvp => new DName(kvp.Key), kvp => new DName(kvp.Value)).ToImmutableDictionary());
-        }       
+            FormulaValue[] enumValues = EnumValues;
+            string[] enumDisplayNames = EnumDisplayNames ?? enumValues.Select(ev => ev.ToObject().ToString()).ToArray();
+
+            return enumDisplayNames.Zip(enumValues, (dn, ev) => new KeyValuePair<string, FormulaValue>(dn, ev)).ToDictionary(kvp => kvp.Key, kvp => kvp.Value);
+        }
     }
 }

src/libraries/Microsoft.PowerFx.Connectors/Public/SupportsConnectorErrors.cs

@@ -16,9 +16,9 @@ public class SupportsConnectorErrors
 
         public IReadOnlyCollection<ErrorResourceKey> Warnings => _warnings;
 
-        private HashSet<string> _errors = null;
+        protected HashSet<string> _errors = null;
 
-        private HashSet<ErrorResourceKey> _warnings = null;
+        protected HashSet<ErrorResourceKey> _warnings = null;
 
         protected SupportsConnectorErrors()
         {

src/libraries/Microsoft.PowerFx.Connectors/Texl/ConnectorTexlFunction.cs

@@ -131,7 +131,9 @@ public override async Task<ConnectorSuggestions> GetConnectorSuggestionsAsync(Fo
             catch (Exception ex)
             {
                 runtimeContext.ExecutionLogger?.LogException(ex, $"Exception in [Texl] {ConnectorFunction.LogFunction(nameof(GetConnectorSuggestionsAsync))} with {LogArguments(arguments)} and position {argPosition} {LogException(ex)}");
-                throw;
+
+                // This is Intellisense and we don't want to throw exceptions to the user
+                return null;
             }
         }
     }

src/libraries/Microsoft.PowerFx.Core/App/ErrorContainers/ErrorContainer.cs

@@ -131,9 +131,7 @@ public TexlError EnsureError(DocumentErrorSeverity severity, Token token, ErrorR
 
             if (!HasErrors(token, severity))
             {
-                var err = new TexlError(token, severity, errKey, args);
-                CollectionUtils.Add(ref _errors, err);
-                return err;
+                Error(severity, token, errKey, args);
             }
 
             return null;
@@ -157,6 +155,11 @@ public TexlError Error(TexlNode node, ErrorResourceKey errKey, params object[] a
             return Error(DefaultSeverity, node, errKey, args);
         }
 
+        public TexlError Error(Token token, ErrorResourceKey errKey, params object[] args)
+        {
+            return Error(DefaultSeverity, token, errKey, args);
+        }
+
         public TexlError Error(DocumentErrorSeverity severity, TexlNode node, ErrorResourceKey errKey, params object[] args)
         {
             Contracts.AssertValue(node);
@@ -167,6 +170,16 @@ public TexlError Error(DocumentErrorSeverity severity, TexlNode node, ErrorResou
             return err;
         }
 
+        public TexlError Error(DocumentErrorSeverity severity, Token token, ErrorResourceKey errKey, params object[] args)
+        {
+            Contracts.AssertValue(token);
+            Contracts.AssertValue(args);
+
+            var err = new TexlError(token, severity, errKey, args);
+            CollectionUtils.Add(ref _errors, err);
+            return err;
+        }
+
         public void Errors(TexlNode node, DType nodeType, KeyValuePair<string, DType> schemaDifference, DType schemaDifferenceType)
         {
             Contracts.AssertValue(node);

src/libraries/Microsoft.PowerFx.Core/Binding/BindInfo/NameLookupInfo.cs

@@ -47,22 +47,21 @@ public NameLookupInfo(BindKind kind, DType type, DPath path, int upCount, object
 
         public bool TryToSymbolEntry(out SymbolEntry x)
         {
-            var ns = this.Data as NameSymbol;
-            if (ns == null)
+            if (this.Data is NameSymbol ns)
             {
-                x = null;
-                return false;
+                x = new SymbolEntry
+                {
+                    Name = ns.Name,
+                    DisplayName = this.DisplayName,                
+                    Properties = ns.Props,
+                    Type = FormulaType.Build(this.Type),
+                    Slot = ns
+                };
+                return true;
             }
 
-            x = new SymbolEntry
-            {
-                Name = ns.Name,
-                DisplayName = this.DisplayName,                
-                Properties = ns.Props,
-                Type = FormulaType.Build(this.Type),
-                Slot = ns
-            };
-            return true;
+            x = null;
+            return false;
         }            
     }
 }