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>