Merge branch 'main' into response-abstraction

.chronus/changes/docs-fix-float32-64-2024-9-17-17-10-6.md

@@ -0,0 +1,8 @@
+---
+# Change versionKind to one of: internal, fix, dependencies, feature, deprecation, breaking
+changeKind: internal
+packages:
+  - "@typespec/compiler"
+---
+
+Fix float32/float64 docs

docs/standard-library/built-in-data-types.md

@@ -303,7 +303,7 @@ scalar float
 
 ### `float32` {#float32}
 
-A 32 bit floating point number. (`±5.0 × 10^−324` to `±1.7 × 10^308`)
+A 32 bit floating point number. (`±1.5 x 10^−45` to `±3.4 x 10^38`)
 ```typespec
 scalar float32
 ```
@@ -312,7 +312,7 @@ scalar float32
 
 ### `float64` {#float64}
 
-A 32 bit floating point number. (`±1.5 x 10^−45` to `±3.4 x 10^38`)
+A 64 bit floating point number. (`±5.0 × 10^−324` to `±1.7 × 10^308`)
 ```typespec
 scalar float64
 ```

eng/emitters/scripts/Generate-APIView-CodeFile.ps1

@@ -11,19 +11,7 @@ if (!(Test-Path -Path $ArtifactPath))
   exit 1
 }
 
-$apiviewParser = "@azure-tools/ts-genapi@1.0.7"
-# Find and install dependencies from public npm registry
-$deps = npm view $apiviewParser --registry $NpmDevopsFeedRegistry dependencies
-if ($deps)
-{
-  $deps = ($deps -replace "[{} ']")
-  $deps = $deps.replace(":", "@").split(",")
-  foreach ($d in $deps)
-  {
-    Write-Host "Instaling $($d)"
-    npm install $d
-  }
-}
+$apiviewParser = "@azure-tools/ts-genapi@2.0.2"
 Write-Host "Installing $($apiviewParser)"
 npm install $apiviewParser --registry $NpmDevopsFeedRegistry
 $installedPath = npm ls @azure-tools/ts-genapi -p
@@ -36,8 +24,6 @@ if (!(Test-Path -Path $installedPath))
 Write-Host "Setting working directory to $($installedPath)"
 Push-Location $installedPath
 try {
-    npm install
-    npm run-script build
     $apiFiles = @(Get-ChildItem -Path $ArtifactPath -Recurse -Filter "*.api.json")
     foreach ($apiPkgFile in $apiFiles)
     {
@@ -47,7 +33,7 @@ try {
         $OutFileName = "$($FileName.split('.')[0])_js.json"
         $OutFilePath = Join-Path -Path $OutDirectory $OutFileName
         Write-Host "Converting api-extractor file $($apiFilePath) to APIview code file $($OutFilePath)"
-        node ./export.js $apiFilePath $OutFilePath
+        node ./dist/export.js $apiFilePath $OutFilePath
     }
 }
 finally

packages/compiler/lib/intrinsics.tsp

@@ -70,12 +70,12 @@ scalar uint8 extends uint16;
 scalar safeint extends int64;
 
 /**
- * A 32 bit floating point number. (`±1.5 x 10^−45` to `±3.4 x 10^38`)
+ * A 64 bit floating point number. (`±5.0 × 10^−324` to `±1.7 × 10^308`)
  */
 scalar float64 extends float;
 
 /**
- * A 32 bit floating point number. (`±5.0 × 10^−324` to `±1.7 × 10^308`)
+ * A 32 bit floating point number. (`±1.5 x 10^−45` to `±3.4 x 10^38`)
  */
 scalar float32 extends float64;
 

packages/http-client-csharp/eng/scripts/Generate.ps1

@@ -52,7 +52,6 @@ $failingSpecs = @(
     Join-Path 'http' 'special-words'
     Join-Path 'http' 'client' 'structure' 'default'
     Join-Path 'http' 'client' 'structure' 'client-operation-group'
-    Join-Path 'http' 'client' 'structure' 'renamed-operation'
     Join-Path 'http' 'client' 'structure' 'two-operation-group'
     Join-Path 'http' 'encode' 'numeric'
     Join-Path 'http' 'parameters' 'body-optionality'

packages/http-client-csharp/generator/Microsoft.Generator.CSharp.ClientModel/src/Providers/ClientProvider.cs

@@ -2,7 +2,6 @@
 // Licensed under the MIT License.
 
 using System;
-using System.ClientModel;
 using System.ClientModel.Primitives;
 using System.Collections.Generic;
 using System.IO;
@@ -35,12 +34,13 @@ public class ClientProvider : TypeProvider
         private readonly FieldProvider? _authorizationHeaderConstant;
         private readonly FieldProvider? _authorizationApiKeyPrefixConstant;
         private FieldProvider? _apiVersionField;
-        private readonly ParameterProvider[] _subClientInternalConstructorParams;
+        private readonly List<ParameterProvider> _subClientInternalConstructorParams;
         private IReadOnlyList<Lazy<ClientProvider>>? _subClients;
         private ParameterProvider? _clientOptionsParameter;
         private ClientOptionsProvider? _clientOptions;
         private RestClientProvider? _restClient;
         private readonly InputParameter[] _allClientParameters;
+        private Lazy<List<FieldProvider>> _additionalClientFields;
 
         private ParameterProvider? ClientOptionsParameter => _clientOptionsParameter ??= ClientOptions != null
             ? ScmKnownParameters.ClientOptions(ClientOptions.Type)
@@ -99,6 +99,8 @@ public ClientProvider(InputClient inputClient)
 
             if (_inputClient.Parent != null)
             {
+                // _clientCachingField will only have subClients (children)
+                // The sub-client caching field for the sub-client which is used for building the caching fields within a parent.
                 _clientCachingField = new FieldProvider(
                     FieldModifiers.Private,
                     Type,
@@ -107,8 +109,13 @@ public ClientProvider(InputClient inputClient)
             }
 
             _endpointParameterName = new(GetEndpointParameterName);
-
+            _additionalClientFields = new Lazy<List<FieldProvider>>(() => BuildAdditionalClientFields());
             _allClientParameters = _inputClient.Parameters.Concat(_inputClient.Operations.SelectMany(op => op.Parameters).Where(p => p.Kind == InputOperationParameterKind.Client)).DistinctBy(p => p.Name).ToArray();
+
+            foreach (var field in _additionalClientFields.Value)
+            {
+                _subClientInternalConstructorParams.Add(field.AsParameter);
+            }
         }
 
         private List<ParameterProvider>? _uriParameters;
@@ -164,6 +171,24 @@ protected override FieldProvider[] BuildFields()
                 }
             }
 
+            fields.AddRange(_additionalClientFields.Value);
+
+            // add sub-client caching fields
+            foreach (var subClient in SubClients)
+            {
+                if (subClient.Value._clientCachingField != null)
+                {
+                    fields.Add(subClient.Value._clientCachingField);
+                }
+            }
+
+            return [.. fields];
+        }
+
+        private List<FieldProvider> BuildAdditionalClientFields()
+        {
+            var fields = new List<FieldProvider>();
+            // Add optional client parameters as fields
             foreach (var p in _allClientParameters)
             {
                 if (!p.IsEndpoint)
@@ -176,7 +201,7 @@ protected override FieldProvider[] BuildFields()
                     {
                         FieldProvider field = new(
                             FieldModifiers.Private | FieldModifiers.ReadOnly,
-                            type,
+                            type.WithNullable(!p.IsRequired),
                             "_" + p.Name.ToVariableName(),
                             this);
                         if (p.IsApiVersion)
@@ -187,17 +212,7 @@ protected override FieldProvider[] BuildFields()
                     }
                 }
             }
-
-            // add sub-client caching fields
-            foreach (var subClient in SubClients)
-            {
-                if (subClient.Value._clientCachingField != null)
-                {
-                    fields.Add(subClient.Value._clientCachingField);
-                }
-            }
-
-            return [.. fields];
+            return fields;
         }
 
         protected override PropertyProvider[] BuildProperties()
@@ -454,6 +469,7 @@ private ParameterProvider BuildClientEndpointParameter()
             };
         }
 
+        // TODO: Update method to be more efficient
         private IReadOnlyList<Lazy<ClientProvider>> GetSubClients()
         {
             var inputClients = ClientModelPlugin.Instance.InputLibrary.InputNamespace.Clients;

packages/http-client-csharp/generator/Microsoft.Generator.CSharp.ClientModel/test/Providers/ClientProviders/ClientProviderTests.cs

@@ -73,7 +73,7 @@ public void TestBuildProperties()
         }
 
         [TestCaseSource(nameof(BuildFieldsTestCases))]
-        public void TestBuildFields(List<InputParameter> inputParameters, bool containsAdditionalOptionalParams)
+        public void TestBuildFields(List<InputParameter> inputParameters, bool containsAdditionalParams)
         {
             var client = InputFactory.Client(TestClientName, parameters: [.. inputParameters]);
             var clientProvider = new ClientProvider(client);
@@ -82,7 +82,7 @@ public void TestBuildFields(List<InputParameter> inputParameters, bool containsA
 
             // validate the fields
             var fields = clientProvider.Fields;
-            if (containsAdditionalOptionalParams)
+            if (containsAdditionalParams)
             {
                 Assert.AreEqual(6, fields.Count);
 
@@ -100,20 +100,20 @@ public void TestBuildFields(List<InputParameter> inputParameters, bool containsA
                 Assert.AreEqual(new CSharpType(typeof(Uri)), endpointField?.Type);
             }
 
-            // validate other optional parameters as fields
-            if (containsAdditionalOptionalParams)
+            // validate other parameters as fields
+            if (containsAdditionalParams)
             {
-                var optionalParamField = fields.FirstOrDefault(f => f.Name == "_optionalParam");
+                var optionalParamField = fields.FirstOrDefault(f => f.Name == "_optionalNullableParam");
                 Assert.IsNotNull(optionalParamField);
-                Assert.AreEqual(new CSharpType(typeof(string)), optionalParamField?.Type);
+                Assert.AreEqual(new CSharpType(typeof(string), isNullable: true), optionalParamField?.Type);
 
-                var optionalParam2Field = fields.FirstOrDefault(f => f.Name == "_optionalParam2");
-                Assert.IsNotNull(optionalParam2Field);
-                Assert.AreEqual(new CSharpType(typeof(string)), optionalParam2Field?.Type);
+                var requiredParam2Field = fields.FirstOrDefault(f => f.Name == "_requiredParam2");
+                Assert.IsNotNull(requiredParam2Field);
+                Assert.AreEqual(new CSharpType(typeof(string), isNullable: false), requiredParam2Field?.Type);
 
-                var optionalParam3Field = fields.FirstOrDefault(f => f.Name == "_optionalParam3");
-                Assert.IsNotNull(optionalParam3Field);
-                Assert.AreEqual(new CSharpType(typeof(long)), optionalParam3Field?.Type);
+                var requiredParam3Field = fields.FirstOrDefault(f => f.Name == "_requiredParam3");
+                Assert.IsNotNull(requiredParam3Field);
+                Assert.AreEqual(new CSharpType(typeof(long), isNullable: false), requiredParam3Field?.Type);
             }
         }
 
@@ -142,6 +142,7 @@ public void TestBuildFields_WithSubClients(InputClient client, bool hasSubClient
             }
             else
             {
+                // The 3 fields are _endpoint, AuthorizationHeader, and _keyCredential
                 Assert.AreEqual(3, fields.Count);
             }
         }
@@ -540,24 +541,28 @@ public static IEnumerable<TestCaseData> BuildFieldsTestCases
                 }, false);
                 yield return new TestCaseData(new List<InputParameter>
                 {
+                    // have to explicitly set isRequired because we now call CreateParameter in buildFields
                     InputFactory.Parameter(
-                        "optionalParam",
+                        "optionalNullableParam",
                         InputPrimitiveType.String,
                         location: RequestLocation.None,
                         defaultValue: InputFactory.Constant.String("someValue"),
-                        kind: InputOperationParameterKind.Client),
+                        kind: InputOperationParameterKind.Client,
+                        isRequired: false),
                     InputFactory.Parameter(
-                        "optionalParam2",
+                        "requiredParam2",
                         InputPrimitiveType.String,
                         location: RequestLocation.None,
                         defaultValue: InputFactory.Constant.String("someValue"),
-                        kind: InputOperationParameterKind.Client),
+                        kind: InputOperationParameterKind.Client,
+                        isRequired: true),
                     InputFactory.Parameter(
-                        "optionalParam3",
+                        "requiredParam3",
                         InputPrimitiveType.Int64,
                         location: RequestLocation.None,
                         defaultValue: InputFactory.Constant.Int64(2),
-                        kind: InputOperationParameterKind.Client),
+                        kind: InputOperationParameterKind.Client,
+                        isRequired: true),
                     InputFactory.Parameter(
                         KnownParameters.Endpoint.Name,
                         InputPrimitiveType.String,

packages/http-client-csharp/generator/Microsoft.Generator.CSharp.ClientModel/test/Providers/MrwSerializationTypeDefinitions/ModelCustomizationTests.cs

@@ -105,5 +105,74 @@ public async Task CanCustomizePropertyUsingField()
             var file = writer.Write();
             Assert.AreEqual(Helpers.GetExpectedFromFile(), file.Content);
         }
+
+        [Test]
+        public async Task CanCustomizeFixedEnumString()
+        {
+            await MockHelpers.LoadMockPluginAsync(compilation: async () => await Helpers.GetCompilationFromDirectoryAsync());
+
+            var props = new[] {
+                InputFactory.EnumMember.String("one", "val1"),
+                InputFactory.EnumMember.String("two", "val2"),
+                InputFactory.EnumMember.String("three", "val3")
+            };
+
+            var inputEnum = InputFactory.Enum("mockInputEnum", underlyingType: InputPrimitiveType.String, values: props, isExtensible: false);
+
+            var modelProp = InputFactory.Property("prop1", inputEnum);
+            var inputModel = InputFactory.Model("mockInputModel", properties: [modelProp], usage: InputModelTypeUsage.Json);
+
+            var plugin = await MockHelpers.LoadMockPluginAsync(
+                inputModels: () => [inputModel],
+                inputEnums: () => [inputEnum],
+                compilation: async () => await Helpers.GetCompilationFromDirectoryAsync());
+
+            var modelProvider = plugin.Object.OutputLibrary.TypeProviders.Single(t => t is ModelProvider);
+            var serializationProvider = modelProvider.SerializationProviders.Single(t => t is MrwSerializationTypeDefinition);
+            Assert.IsNotNull(serializationProvider);
+            var writer = new TypeProviderWriter(serializationProvider);
+            var file = writer.Write();
+            Assert.AreEqual(Helpers.GetExpectedFromFile(), file.Content);
+        }
+
+        [Test]
+        public async Task CanCustomizeStringToFixedEnum()
+        {
+            await MockHelpers.LoadMockPluginAsync(compilation: async () => await Helpers.GetCompilationFromDirectoryAsync());
+
+            var modelProp = InputFactory.Property("prop1", InputPrimitiveType.String);
+            var inputModel = InputFactory.Model("mockInputModel", properties: [modelProp], usage: InputModelTypeUsage.Json);
+
+            var plugin = await MockHelpers.LoadMockPluginAsync(
+                inputModels: () => [inputModel],
+                compilation: async () => await Helpers.GetCompilationFromDirectoryAsync());
+
+            var modelProvider = plugin.Object.OutputLibrary.TypeProviders.Single(t => t is ModelProvider);
+            var serializationProvider = modelProvider.SerializationProviders.Single(t => t is MrwSerializationTypeDefinition);
+            Assert.IsNotNull(serializationProvider);
+            var writer = new TypeProviderWriter(serializationProvider);
+            var file = writer.Write();
+            Assert.AreEqual(Helpers.GetExpectedFromFile(), file.Content);
+        }
+
+        [Test]
+        public async Task CanCustomizeNullableStringToFixedEnum()
+        {
+            await MockHelpers.LoadMockPluginAsync(compilation: async () => await Helpers.GetCompilationFromDirectoryAsync());
+
+            var modelProp = InputFactory.Property("prop1", new InputNullableType(InputPrimitiveType.String));
+            var inputModel = InputFactory.Model("mockInputModel", properties: [modelProp], usage: InputModelTypeUsage.Json);
+
+            var plugin = await MockHelpers.LoadMockPluginAsync(
+                inputModels: () => [inputModel],
+                compilation: async () => await Helpers.GetCompilationFromDirectoryAsync());
+
+            var modelProvider = plugin.Object.OutputLibrary.TypeProviders.Single(t => t is ModelProvider);
+            var serializationProvider = modelProvider.SerializationProviders.Single(t => t is MrwSerializationTypeDefinition);
+            Assert.IsNotNull(serializationProvider);
+            var writer = new TypeProviderWriter(serializationProvider);
+            var file = writer.Write();
+            Assert.AreEqual(Helpers.GetExpectedFromFile(), file.Content);
+        }
     }
 }