Updates to support partial methods and nested types in containers. Bug fix for get model[T] to show up correctly. Remove obsolete flag from container methods for passing the target document.

Author: sgiffinlcd

src/CodeFactoryVisualStudio/CodeFactory.DotNet/CSharp/CsClass.cs

@@ -30,10 +30,13 @@ public abstract class CsClass:CsContainer,ICsClass
  /// <param name="loadedFromSource">Flag that determines if the model was loaded from source code or from an existing library.</param>
  /// <param name="language">The target language the model was generated from.</param>
  /// <param name="members">The members assigned to this container.</param>
+ /// <param name="isNested">Flag that determines if the container type is nested in another type definition.</param>
+ /// <param name="nestedType">Enumeration of the type of nesting the container is.</param>
+ /// <param name="nestedModels">List of nested models assigned to this container. This is an optional parameter and can be null</param>
  /// <param name="baseClass">The class model that is base class of this class.</param>
  /// <param name="sourceDocument">The source document that was used to build this model. This is optional parameter and can be null.</param>
  /// <param name="modelStore">Optional the lookup storage for models created during the compile or lookup of the model.</param>
- /// <param name="modelErrors">Optional the error that occured while creating the model.</param>
+ /// <param name="modelErrors">Optional the error that occurred while creating the model.</param>
  /// <param name="attributes">List of the attributes assigned to this model.</param>
  /// <param name="isGeneric">Flag that determines if the container is a generic definition.</param>
  /// <param name="hasStrongTypesInGenerics">Flag that determines if the generics use strong type definitions.</param>
@@ -56,13 +59,13 @@ protected CsClass(bool isLoaded, bool hasErrors, bool loadedFromSource, SourceCo
  IReadOnlyList<CsAttribute> attributes, bool isGeneric, bool hasStrongTypesInGenerics,
  IReadOnlyList<CsGenericParameter> genericParameters, IReadOnlyList<CsType> genericTypes, string modelSourceFile, IReadOnlyList<string> sourceFiles,
  bool hasDocumentation, string documentation, string lookupPath, string name, string ns, string parentPath, 
- CsSecurity security, IReadOnlyList<CsInterface> inheritedInterfaces, IReadOnlyList<CsMember> members,
- bool isStatic, bool isAbstract, bool isSealed, CsClass baseClass, string sourceDocument = null, 
+ CsSecurity security, IReadOnlyList<CsInterface> inheritedInterfaces, IReadOnlyList<CsMember> members,bool isNested, CsNestedType nestedType, 
+ bool isStatic, bool isAbstract, bool isSealed, CsClass baseClass,IReadOnlyList<ICsNestedModel> nestedModels, string sourceDocument = null, 
  ModelStore<ICsModel> modelStore = null, IReadOnlyList<ModelLoadException> modelErrors = null)
  : base(isLoaded, hasErrors, loadedFromSource, language, CsModelType.Class, attributes, 
  isGeneric, hasStrongTypesInGenerics, genericParameters, genericTypes, modelSourceFile, sourceFiles, hasDocumentation,
  documentation, lookupPath, name, ns, parentPath, CsContainerType.Class, security, inheritedInterfaces, 
- members, sourceDocument, modelStore, modelErrors)
+ members,isNested,nestedType,nestedModels, sourceDocument, modelStore, modelErrors)
  {
  _isStatic = isStatic;
  _isAbstract = isAbstract;

src/CodeFactoryVisualStudio/CodeFactory.DotNet/CSharp/CsContainer.cs

@@ -16,7 +16,7 @@ namespace CodeFactory.DotNet.CSharp
  /// <summary>
  /// Data model that implements the base implement for all models that support members.
  /// </summary>
- public abstract class CsContainer:CsModel,ICsContainer
+ public abstract class CsContainer:CsModel,ICsContainer,ICsNestedModel
  {
  #region Property backing fields
  private readonly IReadOnlyList<CsAttribute> _attributes;
@@ -35,6 +35,10 @@ public abstract class CsContainer:CsModel,ICsContainer
  private readonly CsSecurity _security;
  private readonly IReadOnlyList<CsInterface> _inheritedInterfaces;
  private readonly IReadOnlyList<CsMember> _members;
+ private readonly bool _isNested;
+ private readonly CsNestedType _nestedType;
+ private readonly IReadOnlyList<ICsNestedModel> _nestedModels;
+
  #endregion
 
  /// <summary>
@@ -46,9 +50,12 @@ public abstract class CsContainer:CsModel,ICsContainer
  /// <param name="language">The target language the model was generated from.</param>
  /// <param name="modelType">The type of code model created.</param>
  /// <param name="members">The members assigned to this container.</param>
+ /// <param name="isNested">Flag that determines if the container type is nested in another type definition.</param>
+ /// <param name="nestedType">Enumeration of the type of nesting the container is.</param>
+ /// <param name="nestedModels">List of nested models assigned to this container. This is an optional parameter and can be null</param>
  /// <param name="sourceDocument">The source document that was used to build this model. This is optional parameter and can be null.</param>
  /// <param name="modelStore">Optional the lookup storage for models created during the compile or lookup of the model.</param>
- /// <param name="modelErrors">Optional the error that occured while creating the model.</param>
+ /// <param name="modelErrors">Optional the error that occurred while creating the model.</param>
  /// <param name="attributes">List of the attributes assigned to this model.</param>
  /// <param name="isGeneric">Flag that determines if the container is a generic definition.</param>
  /// <param name="hasStrongTypesInGenerics">Flag that determines if the generics use strong type definitions.</param>
@@ -70,8 +77,9 @@ protected CsContainer(bool isLoaded, bool hasErrors, bool loadedFromSource, Sour
  IReadOnlyList<CsGenericParameter> genericParameters, IReadOnlyList<CsType> genericTypes, string modelSourceFile,
  IReadOnlyList<string> sourceFiles, bool hasDocumentation, string documentation, string lookupPath,
  string name, string ns, string parentPath, CsContainerType containerType, CsSecurity security,
- IReadOnlyList<CsInterface> inheritedInterfaces, IReadOnlyList<CsMember> members,
- string sourceDocument = null, ModelStore<ICsModel> modelStore = null, IReadOnlyList<ModelLoadException> modelErrors = null)
+ IReadOnlyList<CsInterface> inheritedInterfaces, IReadOnlyList<CsMember> members, bool isNested, CsNestedType nestedType, IReadOnlyList<ICsNestedModel> nestedModels = null,
+
+ string sourceDocument = null, ModelStore<ICsModel> modelStore = null, IReadOnlyList<ModelLoadException> modelErrors = null)
  : base(isLoaded, hasErrors, loadedFromSource, language, modelType, sourceDocument, modelStore, modelErrors)
  {
  _attributes = attributes ?? ImmutableList<CsAttribute>.Empty;
@@ -91,6 +99,9 @@ protected CsContainer(bool isLoaded, bool hasErrors, bool loadedFromSource, Sour
  _security = security;
  _inheritedInterfaces = inheritedInterfaces ?? ImmutableList<CsInterface>.Empty;
  _members = members ?? ImmutableList<CsMember>.Empty;
+ _isNested = isNested;
+ _nestedType = nestedType;
+ _nestedModels = nestedModels ?? ImmutableList<ICsNestedModel>.Empty;
  }
 
  /// <summary>
@@ -214,7 +225,7 @@ protected CsContainer(bool isLoaded, bool hasErrors, bool loadedFromSource, Sour
  /// List of the methods that are implemented in this container.
  /// </summary>
  public IReadOnlyList<CsMethod> Methods => _members.Where(m => m.MemberType == CsMemberType.Method)
- .Cast<CsMethod>().Where(m => m.MethodType == CsMethodType.Member)
+ .Cast<CsMethod>().Where(m => m.MethodType == CsMethodType.Member | m.MethodType == CsMethodType.PartialImplementation | m.MethodType == CsMethodType.PartialDefinition)
  .ToImmutableList() ?? ImmutableList<CsMethod>.Empty;
 
  /// <summary>
@@ -230,6 +241,60 @@ protected CsContainer(bool isLoaded, bool hasErrors, bool loadedFromSource, Sour
  public IReadOnlyList<CsEvent> Events => _members.Where(m => m.MemberType == CsMemberType.Event).Cast<CsEvent>()
  .ToImmutableList() ?? ImmutableList<CsEvent>.Empty;
 
+ /// <summary>
+ /// Models that are nested in the implementation of this container.
+ /// </summary>
+ public IReadOnlyList<ICsNestedModel> NestedModels => _nestedModels;
+
+ /// <summary>
+ /// Classes that are nested in this container.
+ /// </summary>
+ public IReadOnlyList<CsClass> NestedClasses =>
+ _nestedModels.Where(n => n.NestedType == CsNestedType.Class).Cast<CsClass>().ToImmutableList();
+
+ /// <summary>
+ /// Interfaces that are nested in this container.
+ /// </summary>
+ public IReadOnlyList<CsInterface> NestedInterfaces =>
+ _nestedModels.Where(n => n.NestedType == CsNestedType.Interface).Cast<CsInterface>().ToImmutableList();
+
+ /// <summary>
+ /// Structures that are nested in this container.
+ /// </summary>
+ public IReadOnlyList<CsStructure> NestedStructures =>
+ _nestedModels.Where(n => n.NestedType == CsNestedType.Structure).Cast<CsStructure>().ToImmutableList();
+
+ /// <summary>
+ /// Enums that are nested in this container.
+ /// </summary>
+ public IReadOnlyList<CsEnum> NestedEnums =>
+ _nestedModels.Where(n => n.NestedType == CsNestedType.Enum).Cast<CsEnum>().ToImmutableList();
+
+ /// <summary>
+ /// Models that are nested in the implementation of this container.
+ /// </summary>
+ IReadOnlyList<IDotNetNestedModel> IDotNetContainer.NestedModels => NestedModels;
+
+ /// <summary>
+ /// Classes that are nested in this container.
+ /// </summary>
+ IReadOnlyList<IDotNetClass> IDotNetContainer.NestedClasses => NestedClasses;
+
+ /// <summary>
+ /// Interfaces that are nested in this container.
+ /// </summary>
+ IReadOnlyList<IDotNetInterface> IDotNetContainer.NestedInterfaces => NestedInterfaces;
+
+ /// <summary>
+ /// Structures that are nested in this container.
+ /// </summary>
+ IReadOnlyList<IDotNetStructure> IDotNetContainer.NestedStructures => NestedStructures;
+
+ /// <summary>
+ /// Enums that are nested in this container.
+ /// </summary>
+ IReadOnlyList<IDotNetEnum> IDotNetContainer.NestedEnums => NestedEnums;
+
  /// <summary>
  /// The source code syntax that is stored in the body of the container model. This will be null if the container was not loaded from source code.
  /// </summary>
@@ -430,5 +495,20 @@ protected CsContainer(bool isLoaded, bool hasErrors, bool loadedFromSource, Sour
 
  /// <inheritdoc/>
  public string ModelSourceFile => _modelSourceFile;
+
+ /// <summary>
+ /// Identifies the type of model that has been nested.
+ /// </summary>
+ DotNetNestedType IDotNetNestedModel.NestedType => (DotNetNestedType) _nestedType ;
+
+ /// <summary>
+ /// Identifies the type of model that has been nested.
+ /// </summary>
+ public CsNestedType NestedType => _nestedType;
+
+ /// <summary>
+ /// Flag that determines if this model is nested in a parent model.
+ /// </summary>
+ public bool IsNested { get; }
  }
 }

src/CodeFactoryVisualStudio/CodeFactory.DotNet/CSharp/CsDelegate.cs

@@ -324,12 +324,12 @@ protected CsDelegate(bool isLoaded, bool hasErrors, bool loadedFromSource, Sourc
  public abstract Task<CsSource> ReplaceAsync(string sourceCode);
 
 
- /// <summary>
- /// Gets a <see cref="ICsModel"/> from the currently loaded source code. 
- /// </summary>
- /// <param name="lookupPath">The fully qualified path to the model to be loaded.</param>
- /// <returns>The loaded model or null if the model could not be found.</returns>
- public CsModel GetModel(string lookupPath) => LookupModel(lookupPath);
+ ///// <summary>
+ ///// Gets a <see cref="ICsModel"/> from the currently loaded source code. 
+ ///// </summary>
+ ///// <param name="lookupPath">The fully qualified path to the model to be loaded.</param>
+ ///// <returns>The loaded model or null if the model could not be found.</returns>
+ //public CsModel GetModel(string lookupPath) => LookupModel(lookupPath);
 
  /// <inheritdoc/>
  public abstract Task<CsSource> AddBeforeAsync(string sourceCode, bool ignoreLeadingModelsAndDocs);

src/CodeFactoryVisualStudio/CodeFactory.DotNet/CSharp/CsEnum.cs

@@ -29,6 +29,9 @@ public abstract class CsEnum:CsModel,ICsEnum
  private readonly string _ns;
  private readonly CsSecurity _security;
  private readonly IReadOnlyList<CsEnumValue> _values;
+ private readonly bool _isNested;
+ private readonly CsNestedType _nestedType;
+
  #endregion
 
  /// <summary>
@@ -39,9 +42,11 @@ public abstract class CsEnum:CsModel,ICsEnum
  /// <param name="loadedFromSource">Flag that determines if the model was loaded from source code or from an existing library.</param>
  /// <param name="language">The target language the model was generated from.</param>
  /// <param name="values">The enumeration values assigned to this enumeration.</param>
+ /// <param name="isNested">Flag that determines if the container type is nested in another type definition.</param>
+ /// <param name="nestedType">Enumeration of the type of nesting the container is.</param>
  /// <param name="sourceDocument">The source document that was used to build this model. This is optional parameter and can be null.</param>
  /// <param name="modelStore">Optional the lookup storage for models created during the compile or lookup of the model.</param>
- /// <param name="modelErrors">Optional the error that occured while creating the model.</param>
+ /// <param name="modelErrors">Optional the error that occurred while creating the model.</param>
  /// <param name="attributes">List of the attributes assigned to this model.</param>
  /// <param name="sourceFiles">List of the fully qualified paths to the source code files this model is defined in.</param>
  /// <param name="hasDocumentation">Flag that determines if the model has XML documentation assigned to it.</param>
@@ -54,7 +59,7 @@ public abstract class CsEnum:CsModel,ICsEnum
  /// <param name="security">The security scope assigned to this model.</param>
  protected CsEnum(bool isLoaded, bool hasErrors, bool loadedFromSource, SourceCodeType language,
  IReadOnlyList<CsAttribute> attributes, string parentPath, bool hasDocumentation, string documentation, string lookupPath,string modelSourceFile,
- IReadOnlyList<string> sourceFiles, string name, string ns, CsSecurity security, IReadOnlyList<CsEnumValue> values, 
+ IReadOnlyList<string> sourceFiles, string name, string ns, CsSecurity security, IReadOnlyList<CsEnumValue> values, bool isNested,CsNestedType nestedType,
  string sourceDocument = null, ModelStore<ICsModel> modelStore = null, IReadOnlyList<ModelLoadException> modelErrors = null): base(isLoaded, hasErrors, loadedFromSource, language, CsModelType.Enum, sourceDocument, modelStore, modelErrors)
  {
  _attributes = attributes ?? ImmutableList<CsAttribute>.Empty;
@@ -68,6 +73,9 @@ protected CsEnum(bool isLoaded, bool hasErrors, bool loadedFromSource, SourceCod
  _ns = ns;
  _security = security;
  _values = values ?? ImmutableList<CsEnumValue>.Empty;
+ _isNested = isNested;
+ _nestedType = nestedType;
+
  }
 
  /// <summary>
@@ -272,7 +280,6 @@ protected CsEnum(bool isLoaded, bool hasErrors, bool loadedFromSource, SourceCod
  /// <inheritdoc/>
  public abstract Task<CsSource> AddBeforeAsync(string sourceCode, bool ignoreLeadingModelsAndDocs);
 
-
  /// <summary>
  /// The security scope assigned to the enumeration.
  /// </summary>
@@ -290,5 +297,20 @@ protected CsEnum(bool isLoaded, bool hasErrors, bool loadedFromSource, SourceCod
 
  /// <inheritdoc/>
  public string ModelSourceFile => _modelSourceFile;
+
+ /// <summary>
+ /// Identifies the type of model that has been nested.
+ /// </summary>
+ DotNetNestedType IDotNetNestedModel.NestedType => (DotNetNestedType)_nestedType;
+
+ /// <summary>
+ /// Identifies the type of model that has been nested.
+ /// </summary>
+ public CsNestedType NestedType => _nestedType;
+
+ /// <summary>
+ /// Flag that determines if this model is nested in a parent model.
+ /// </summary>
+ public bool IsNested => _isNested;
  }
 }

src/CodeFactoryVisualStudio/CodeFactory.DotNet/CSharp/CsInterface.cs

@@ -21,6 +21,9 @@ public abstract class CsInterface:CsContainer,ICsInterface
  /// <param name="loadedFromSource">Flag that determines if the model was loaded from source code or from an existing library.</param>
  /// <param name="language">The target language the model was generated from.</param>
  /// <param name="members">The members assigned to this container.</param>
+ /// <param name="isNested">Flag that determines if the container type is nested in another type definition.</param>
+ /// <param name="nestedType">Enumeration of the type of nesting the container is.</param>
+ /// <param name="nestedModels">List of nested models assigned to this container. This is an optional parameter and can be null</param>
  /// <param name="sourceDocument">The source document that was used to build this model. This is optional parameter and can be null.</param>
  /// <param name="modelStore">Optional the lookup storage for models created during the compile or lookup of the model.</param>
  /// <param name="modelErrors">Optional the error that occured while creating the model.</param>
@@ -45,11 +48,11 @@ protected CsInterface(bool isLoaded, bool hasErrors, bool loadedFromSource, Sour
  IReadOnlyList<CsType> genericTypes, string modelSourceFile, IReadOnlyList<string> sourceFiles, bool hasDocumentation, 
  string documentation, string lookupPath, string name, string ns, string parentPath, 
  CsSecurity security, IReadOnlyList<CsInterface> inheritedInterfaces,
- IReadOnlyList<CsMember> members, string sourceDocument = null, ModelStore<ICsModel> modelStore = null, IReadOnlyList<ModelLoadException> modelErrors = null)
+ IReadOnlyList<CsMember> members, bool isNested,CsNestedType nestedType, IReadOnlyList<ICsNestedModel> nestedModels = null, string sourceDocument = null, ModelStore<ICsModel> modelStore = null, IReadOnlyList<ModelLoadException> modelErrors = null)
  : base(isLoaded, hasErrors, loadedFromSource, language, CsModelType.Interface,attributes, 
  isGeneric, hasStrongTypesInGenerics, genericParameters, genericTypes,modelSourceFile, sourceFiles, hasDocumentation, 
  documentation, lookupPath, name, ns, parentPath, CsContainerType.Interface, security, inheritedInterfaces, 
- members, sourceDocument, modelStore, modelErrors)
+ members,isNested,nestedType,nestedModels, sourceDocument, modelStore, modelErrors)
  {
  //Intentionally blank
  }

src/CodeFactoryVisualStudio/CodeFactory.DotNet/CSharp/CsMethodType.cs

@@ -60,6 +60,16 @@ public enum CsMethodType
  /// </summary>
  Remove = DotNetMethodType.Remove,
 
+ /// <summary>
+ /// This method is the definition for a partial method.
+ /// </summary>
+ PartialDefinition = DotNetMethodType.PartialDefinition,
+
+ /// <summary>
+ /// This method is the implementation for a partial method.
+ /// </summary>
+ PartialImplementation = DotNetMethodType.PartialImplementation,
+
  /// <summary>
  /// The type of method is unknown
  /// </summary>