Many fixes (in comments) (Azure#49)

* virtual-properties, memory increase, minor fixes

* inline properties step

* remove message about actual path

* Added System.AttachDebugger.Break() and fixed string serializition of enum that has a null value

* temp fix for wildcard deserializer

* explictly set the collection type in wildcard

* changing incubator to powershell

* incubator => powershell

* extending interface to azaccounts

* Updated debugability, fixed error handling, extended azmodule suport, and more

Author: fearthecowboy

docs/development.md

@@ -118,7 +118,6 @@ load-priority: 1001
 
 
 ``` yaml 
-powershellincubator: true
 enable-multi-api: true
 
 api-folder: private/api

extensions/csharp-v2/src/operation/method.ts

@@ -148,7 +148,7 @@ export class OperationMethod extends Method {
         ${queryParams.length > 0 ? '+ "?"' : ''}${queryParams.joinWith(pp => `
         + ${pp.serializeToNode(KnownMediaType.QueryParameter, pp.param.name).value}`, `
         + "&"`
-            )}
+          )}
         ).TrimEnd('?','&')`)
         });
         yield url.declarationStatement;
@@ -227,6 +227,12 @@ export class EventListener {
       yield `await ${this.expression.value}.Signal(${eventName}${params});`;
     }
   }
+  *snycSignalNoCheck(eventName: Expression, ...additionalParameters: Array<string | Expression>) {
+    if (this.emitSignals) {
+      const params = additionalParameters.length > 0 ? `, ${additionalParameters.joinWith(each => typeof each === 'string' ? each : each.value)}` : ``;
+      yield `${this.expression.value}.Signal(${eventName}${params}).Wait();`;
+    }
+  }
   *signal(eventName: Expression, ...additionalParameters: Array<string | Expression>) {
     if (this.emitSignals) {
       const params = additionalParameters.length > 0 ? `, ${additionalParameters.joinWith(each => typeof each === 'string' ? each : each.value)}` : ``;

extensions/csharp-v2/src/plugin-namer.ts

@@ -3,17 +3,14 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { codemodel, JsonType, processCodeModel, ModelState, VirtualProperty } from '@microsoft.azure/autorest.codemodel-v3';
+import { codemodel, JsonType, ModelState, processCodeModel, VirtualProperty } from '@microsoft.azure/autorest.codemodel-v3';
 
-import { items, length, values, keys, Dictionary, excludeXDash } from '@microsoft.azure/codegen';
-
-
-import { camelCase, deconstruct, fixLeadingNumber, pascalCase } from '@microsoft.azure/codegen';
+import { camelCase, deconstruct, Dictionary, excludeXDash, fixLeadingNumber, items, keys, length, pascalCase, values } from '@microsoft.azure/codegen';
 import { System } from '@microsoft.azure/codegen-csharp';
 
+import { Host } from '@microsoft.azure/autorest-extension-base';
 import { SchemaDetails } from './code-model';
 import { SchemaDefinitionResolver } from './schema/schema-resolver';
-import { Host } from '@microsoft.azure/autorest-extension-base';
 
 export async function csnamer(service: Host) {
   return processCodeModel(nameStuffRight, service);
@@ -169,21 +166,21 @@ async function nameStuffRight(codeModel: codemodel.Model, service: Host): Promis
     }
   }
   /* IN PROGRESS : GS01
-  
+
     for (const each of values(codeModel.schemas).linq.where(each => !!each.details.csharp.virtualProperties)) {
       // on models that have virtual properties, we're going to set nice c# names for each of them.
       const virtualProperties = <Dictionary<VirtualProperty>>each.details.csharp.virtualProperties;
-  
+
       const mine = items(virtualProperties).linq.where(each => each.value.kind === 'my-property').linq.toArray();
       const parents = items(virtualProperties).linq.where(each => each.value.kind === 'parent-property').linq.toArray();
       const children = items(virtualProperties).linq.where(each => each.value.kind === 'child-property').linq.toArray();
-  
+
       // our new virtual properties go here.
       const newVirtualProperties = new Dictionary<VirtualProperty>();
-  
+
       // my properties (easy)
       for (const kv of values(mine)) {
-        // strategy: use the least amount of things from 'propertyName' starting with the end. 
+        // strategy: use the least amount of things from 'propertyName' starting with the end.
         let name = '';
         for (let i = kv.value.propertyName.length; i > 0; i--) {
           name = `${name}${toPascal(kv.value.propertyName[i - 1])}`;
@@ -197,10 +194,10 @@ async function nameStuffRight(codeModel: codemodel.Model, service: Host): Promis
           }
         }
       }
-  
+
       // parent properties (easy-ish)
       for (const kv of values(parents)) {
-        // strategy: use the least amount of things from 'propertyName' starting with the end. 
+        // strategy: use the least amount of things from 'propertyName' starting with the end.
         let name = '';
         for (let i = kv.value.propertyName.length; i > 0; i--) {
           name = `${name}${toPascal(kv.value.propertyName[i - 1])}`;

extensions/csharp-v2/src/schema/schema-resolver.ts

@@ -22,12 +22,10 @@ import { ObjectImplementation } from './object';
 import { String } from './string';
 import { Uuid } from './Uuid';
 import { UntypedWildcard, Wildcard } from './wildcard';
-
 import { EnhancedTypeDeclaration } from './extended-type-declaration';
 
-
 export class SchemaDefinitionResolver {
-  private cache = new Map<string, EnhancedTypeDeclaration>();
+  private readonly cache = new Map<string, EnhancedTypeDeclaration>();
   private add(schema: Schema, value: EnhancedTypeDeclaration): EnhancedTypeDeclaration {
     this.cache.set(schema.details.default.name, value);
     return value;

extensions/csharp-v2/src/schema/wildcard.ts

@@ -24,25 +24,25 @@ export class Wildcard implements EnhancedTypeDeclaration {
   }
 
   get declaration(): string {
-    return `System.Collections.Generic.IDictionary<string,${this.leafType.declaration}>`;
+    return `System.Collections.Hashtable`;
   }
 
   /** emits an expression to deserialize a property from a member inside a container */
   deserializeFromContainerMember(mediaType: KnownMediaType, container: ExpressionOrLiteral, serializedName: string, defaultValue: Expression): Expression {
     switch (mediaType) {
       case KnownMediaType.Json:
-        return toExpression(`/* 1 */ System.Linq.Enumerable.ToDictionary<string,string, ${this.leafType.declaration}>( ${valueOf(container)}.Property("${serializedName}")?.Keys ?? System.Linq.Enumerable.Empty<string>(), each => each, each => ${this.leafType.deserializeFromNode(mediaType, `${valueOf(container)}.Property("${serializedName}").PropertyT<${ClientRuntime.JsonNode}>(each)`, toExpression('null'))} )`);
+        return toExpression(`/* 1 */ new System.Collections.Hashtable( System.Linq.Enumerable.ToDictionary<string,string, ${this.leafType.declaration}>( ${valueOf(container)}.Property("${serializedName}")?.Keys ?? System.Linq.Enumerable.Empty<string>(), each => each, each => ${this.leafType.deserializeFromNode(mediaType, `${valueOf(container)}.Property("${serializedName}").PropertyT<${ClientRuntime.JsonNode}>(each)`, toExpression('null'))} ))`);
 
       case KnownMediaType.Xml:
-        return toExpression(`System.Linq.Enumerable.ToDictionary<string,string, ${this.leafType.declaration}>( ${valueOf(container)}?.Elements() ?? System.Linq.Enumerable.Empty<System.Xml.Linq.XElement>(), element => element.Name.ToString(), element => ${this.leafType.deserializeFromNode(mediaType, 'element', toExpression('null'))} )`);
+        return toExpression(`new System.Collections.Hashtable(System.Linq.Enumerable.ToDictionary<string,string, ${this.leafType.declaration}>( ${valueOf(container)}?.Elements() ?? System.Linq.Enumerable.Empty<System.Xml.Linq.XElement>(), element => element.Name.ToString(), element => ${this.leafType.deserializeFromNode(mediaType, 'element', toExpression('null'))} ))`);
 
       case KnownMediaType.Header: {
         const prefix = this.schema.extensions['x-ms-header-collection-prefix'];
         if (prefix) {
           // this is a catch for a specific set of headers
-          return toExpression(`System.Linq.Enumerable.ToDictionary<string,string, ${this.leafType.declaration}>(System.Linq.Enumerable.Where(${valueOf(container)}, header => header.Key.StartsWith("${serializedName}")), header => header.Key.Substring(${serializedName.length}), header => System.Linq.Enumerable.FirstOrDefault(header.Value))`);
+          return toExpression(`new System.Collections.Hashtable(System.Linq.Enumerable.ToDictionary<string,string, ${this.leafType.declaration}>(System.Linq.Enumerable.Where(${valueOf(container)}, header => header.Key.StartsWith("${serializedName}")), header => header.Key.Substring(${serializedName.length}), header => System.Linq.Enumerable.FirstOrDefault(header.Value)))`);
         }
-        return toExpression(`System.Linq.Enumerable.ToDictionary<string,string, ${this.leafType.declaration}>( ${valueOf(container)}?.Elements() ?? System.Linq.Enumerable.Empty<System.Xml.Linq.XElement>(), element => element.Name.ToString(), element => ${this.leafType.deserializeFromNode(mediaType, 'element', toExpression('null'))} )`);
+        return toExpression(`new System.Collections.Hashtable(System.Linq.Enumerable.ToDictionary<string,string, ${this.leafType.declaration}>( ${valueOf(container)}?.Elements() ?? System.Linq.Enumerable.Empty<System.Xml.Linq.XElement>(), element => element.Name.ToString(), element => ${this.leafType.deserializeFromNode(mediaType, 'element', toExpression('null'))} ))`);
       }
     }
     return toExpression(`null /* deserializeFromContainerMember (wildcard) doesn't support '${mediaType}' ${__filename}*/`);
@@ -53,7 +53,7 @@ export class Wildcard implements EnhancedTypeDeclaration {
     switch (mediaType) {
       case KnownMediaType.Json:
         const nodeAsObject = `(${(valueOf(node))} as ${ClientRuntime.JsonObject})`;
-        return toExpression(`/* 2 */ System.Linq.Enumerable.ToDictionary<string,string, ${this.leafType.declaration}>( ${nodeAsObject}?.Keys ?? System.Linq.Enumerable.Empty<string>(), each => each, each => ${this.leafType.deserializeFromNode(mediaType, `${nodeAsObject}.PropertyT<${ClientRuntime.JsonNode}>(each)`, toExpression('null'))} )`);
+        return toExpression(`/* 2 */ new System.Collections.Hashtable(System.Linq.Enumerable.ToDictionary<string,string, ${this.leafType.declaration}>( ${nodeAsObject}?.Keys ?? System.Linq.Enumerable.Empty<string>(), each => each, each => ${this.leafType.deserializeFromNode(mediaType, `${nodeAsObject}.PropertyT<${ClientRuntime.JsonNode}>(each)`, toExpression('null'))} ))`);
     }
     return toExpression(`null /* deserializeFromNode (wildcard) doesn't support '${mediaType}' ${__filename}*/`);
   }
@@ -90,13 +90,23 @@ export class Wildcard implements EnhancedTypeDeclaration {
 
   /** emits the code required to serialize this into a container */
   serializeToContainerMember(mediaType: KnownMediaType, value: ExpressionOrLiteral, container: Variable, serializedName: string): OneOrMoreStatements {
+    const $this = this;
     try {
       const each = pushTempVar();
       const item = pushTempVar();
+      const eachvalue = pushTempVar();
+      const innerContainer = pushTempVar();
 
       switch (mediaType) {
         case KnownMediaType.Json:
-          return If(`null != ${value}`, ForEach(each, toExpression(value), `AddIf( ${this.leafType.serializeToNode(mediaType, `${each}.Value`, `$$$`)},(${item}) => ${container}.Add(${each}.Key,${item} ) );`));
+          return If(`null != ${value}`, function* () {
+            yield `var ${innerContainer} = ${ClientRuntime.JsonObject.new()};`;
+            yield `${container}.Add("${serializedName}", ${innerContainer});`;
+            yield ForEach(each, `${toExpression(value)}.Keys`, function* () {
+              yield `var ${eachvalue} = ${value}[${each}];`;
+              yield `AddIf( ${$this.leafType.serializeToNode(mediaType, `${eachvalue} as ${$this.leafType.declaration}`, `$$$`)},(${item}) => ${innerContainer}.Add(${each} as string,${item} ) );`;
+            });
+          });
 
         case KnownMediaType.Xml:
           return If(`null != ${value}`, ForEach(each, toExpression(value), `AddIf( ${this.leafType.serializeToNode(mediaType, `${each}.Value`, `$$$`)},${container}.Add );`.replace('"$$$"', `${each}.Key`)));
@@ -110,6 +120,8 @@ export class Wildcard implements EnhancedTypeDeclaration {
     } finally {
       popTempVar();
       popTempVar();
+      popTempVar();
+      popTempVar();
     }
     return `/* serializeToContainerMember (wildcard) doesn't support '${mediaType}' ${__filename}*/`;
   }
@@ -187,7 +199,7 @@ export class UntypedWildcard implements EnhancedTypeDeclaration {
   isRequired = false;
 
   get declaration(): string {
-    return `System.Collections.Generic.Dictionary<string,object>`;
+    return `System.Collections.Hashtable`;
   }
   public validatePresence(eventListener: Variable, property: Variable): string {
     return `await ${eventListener}.AssertNotNull(${nameof(property.value)},${property});`.trim();