private void GenerateType(IndentedStringBuilder writer, INamedTypeSymbol ownerType)
        {
            if (_typeMap.ContainsKey(ownerType))
            {
                return;
            }

            var ownerTypeName = GetGlobalQualifier(ownerType) + ownerType.ToString();

            var flattenedProperties =
                from property in ownerType.GetAllProperties()
                where !property.IsStatic &&
                !IsIgnoredType(property.ContainingSymbol as INamedTypeSymbol) &&
                !IsNonBindable(property) &&
                !IsOverride(property.GetMethod)
                select property;

            var properties =
                from property in ownerType.GetProperties()
                where !property.IsStatic &&
                !IsNonBindable(property) &&
                HasPublicGetter(property) &&
                !IsOverride(property.GetMethod)
                select property;

            var propertyDependencyProperties =
                from property in ownerType.GetProperties()
                where property.IsStatic &&
                Equals(property.Type, _dependencyPropertySymbol)
                select property.Name;

            var fieldDependencyProperties =
                from field in ownerType.GetFields()
                where field.IsStatic &&
                Equals(field.Type, _dependencyPropertySymbol)
                select field.Name;

            var dependencyProperties = fieldDependencyProperties
                                       .Concat(propertyDependencyProperties)
                                       .ToArray();

            properties = from prop in properties.Distinct(new PropertyNameEqualityComparer())
                         where !dependencyProperties.Contains(prop.Name + "Property")
                         select prop;

            properties = properties
                         .ToArray();

            var typeInfo = new GeneratedTypeInfo(
                index: _typeMap.Count,
                hasProperties: properties.Any() || dependencyProperties.Any()
                );

            _typeMap.Add(ownerType, typeInfo);

            var baseType = GetBaseType(ownerType);

            // Call the builders for the base types
            if (baseType != null)
            {
                GenerateType(writer, baseType);
            }

            writer.AppendLineInvariant("/// <summary>");
            writer.AppendLineInvariant("/// Builder for {0}", ownerType.GetFullName());
            writer.AppendLineInvariant("/// </summary>");
            writer.AppendLineInvariant("[System.Runtime.CompilerServices.CompilerGeneratedAttribute]");
            writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1502:AvoidExcessiveComplexity\", Justification=\"Must be ignored even if generated code is checked.\")]");
            writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1506:AvoidExcessiveClassCoupling\", Justification = \"Must be ignored even if generated code is checked.\")]");

            AnalyzerSuppressionsGenerator.Generate(writer, AnalyzerSuppressions);
            using (writer.BlockInvariant("static class MetadataBuilder_{0:000}", typeInfo.Index))
            {
                var postWriter = new IndentedStringBuilder();
                postWriter.Indent(writer.CurrentLevel);

                // Generate a parameter-less build to avoid generating a lambda during registration (avoids creating a caching backing field)
                writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1502:AvoidExcessiveComplexity\", Justification=\"Must be ignored even if generated code is checked.\")]");
                writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1506:AvoidExcessiveClassCoupling\", Justification = \"Must be ignored even if generated code is checked.\")]");
                writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1505:AvoidUnmaintainableCode\", Justification = \"Must be ignored even if generated code is checked.\")]");
                using (writer.BlockInvariant("internal static global::Uno.UI.DataBinding.IBindableType Build()"))
                {
                    writer.AppendLineInvariant("return Build(null);");
                }

                writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1502:AvoidExcessiveComplexity\", Justification=\"Must be ignored even if generated code is checked.\")]");
                writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1506:AvoidExcessiveClassCoupling\", Justification = \"Must be ignored even if generated code is checked.\")]");
                writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1505:AvoidUnmaintainableCode\", Justification = \"Must be ignored even if generated code is checked.\")]");
                using (writer.BlockInvariant("internal static global::Uno.UI.DataBinding.IBindableType Build(global::Uno.UI.DataBinding.BindableType parent)"))
                {
                    writer.AppendLineInvariant(
                        @"var bindableType = parent ?? new global::Uno.UI.DataBinding.BindableType({0}, typeof({1}));",
                        flattenedProperties
                        .Where(p => !IsStringIndexer(p) && HasPublicGetter(p))
                        .Count()
                        , ExpandType(ownerType)
                        );

                    // Call the builders for the base types
                    if (baseType != null)
                    {
                        var baseTypeMapped = _typeMap.UnoGetValueOrDefault(baseType);

                        writer.AppendLineInvariant(@"MetadataBuilder_{0:000}.Build(bindableType); // {1}", baseTypeMapped.Index, ExpandType(baseType));
                    }

                    var ctor = ownerType.GetMethods().FirstOrDefault(m => m.MethodKind == MethodKind.Constructor && !m.Parameters.Any() && m.IsLocallyPublic(_currentModule));

                    if (ctor != null && IsCreateable(ownerType))
                    {
                        using (writer.BlockInvariant("if(parent == null)"))
                        {
                            writer.AppendLineInvariant(@"bindableType.AddActivator(CreateInstance);");
                            postWriter.AppendLineInvariant($@"private static object CreateInstance() => new {ownerTypeName}();");
                        }
                    }

                    foreach (var property in properties)
                    {
                        var propertyTypeName = property.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
                        var propertyName     = property.Name;

                        if (IsStringIndexer(property))
                        {
                            writer.AppendLineInvariant("bindableType.AddIndexer(GetIndexer, SetIndexer);");

                            postWriter.AppendLineInvariant($@"private static object GetIndexer(object instance, string name) => (({ownerTypeName})instance)[name];");

                            if (property.SetMethod != null)
                            {
                                postWriter.AppendLineInvariant($@"private static void SetIndexer(object instance, string name, object value) => (({ownerTypeName})instance)[name] = ({propertyTypeName})value;");
                            }
                            else
                            {
                                postWriter.AppendLineInvariant("private static void SetIndexer(object instance, string name, object value) {{}}");
                            }

                            continue;
                        }

                        if (property.IsIndexer)
                        {
                            // Other types of indexers are currently not supported.
                            continue;
                        }

                        if (
                            property.SetMethod != null &&
                            property.SetMethod != null &&
                            property.SetMethod.IsLocallyPublic(_currentModule)
                            )
                        {
                            if (property.Type.IsValueType)
                            {
                                writer.AppendLineInvariant($@"bindableType.AddProperty(""{propertyName}"", typeof({propertyTypeName}), Get{propertyName}, Set{propertyName});");

                                postWriter.AppendLineInvariant($@"private static object Get{propertyName}(object instance, Windows.UI.Xaml.DependencyPropertyValuePrecedences? precedence) => (({ownerTypeName})instance).{propertyName};");

                                using (postWriter.BlockInvariant($@"private static void Set{propertyName}(object instance, object value, Windows.UI.Xaml.DependencyPropertyValuePrecedences? precedence)"))
                                {
                                    using (postWriter.BlockInvariant($"if(value != null)"))
                                    {
                                        postWriter.AppendLineInvariant($"(({ownerTypeName})instance).{propertyName} = ({propertyTypeName})value;");
                                    }
                                }
                            }
                            else
                            {
                                writer.AppendLineInvariant($@"bindableType.AddProperty(""{propertyName}"", typeof({propertyTypeName}), Get{propertyName}, Set{propertyName});");

                                postWriter.AppendLineInvariant($@"private static object Get{propertyName}(object instance,  Windows.UI.Xaml.DependencyPropertyValuePrecedences? precedence) => (({ownerTypeName})instance).{propertyName};");
                                postWriter.AppendLineInvariant($@"private static void Set{propertyName}(object instance, object value, Windows.UI.Xaml.DependencyPropertyValuePrecedences? precedence) => (({ownerTypeName})instance).{propertyName} = ({propertyTypeName})value;");
                            }
                        }
                        else if (HasPublicGetter(property))
                        {
                            writer.AppendLineInvariant($@"bindableType.AddProperty(""{propertyName}"", typeof({propertyTypeName}), Get{propertyName});");

                            postWriter.AppendLineInvariant($@"private static object Get{propertyName}(object instance, Windows.UI.Xaml.DependencyPropertyValuePrecedences? precedence) => (({ownerTypeName})instance).{propertyName};");
                        }
                    }

                    foreach (var dependencyProperty in dependencyProperties)
                    {
                        var propertyName = dependencyProperty.TrimEnd("Property");

                        var getMethod = ownerType.GetMethods().FirstOrDefault(m => m.Name == "Get" + propertyName && m.Parameters.Length == 1 && m.IsLocallyPublic(_currentModule));
                        var setMethod = ownerType.GetMethods().FirstOrDefault(m => m.Name == "Set" + propertyName && m.Parameters.Length == 2 && m.IsLocallyPublic(_currentModule));

                        if (getMethod == null)
                        {
                            getMethod = ownerType
                                        .GetProperties()
                                        .FirstOrDefault(p => p.Name == propertyName && (p.GetMethod?.IsLocallyPublic(_currentModule) ?? false))
                                        ?.GetMethod;
                        }

                        if (getMethod != null)
                        {
                            var getter = $"{XamlConstants.Types.DependencyObjectExtensions}.GetValue(instance, {ownerTypeName}.{propertyName}Property, precedence)";
                            var setter = $"{XamlConstants.Types.DependencyObjectExtensions}.SetValue(instance, {ownerTypeName}.{propertyName}Property, value, precedence)";

                            var propertyType = GetGlobalQualifier(getMethod.ReturnType) + SanitizeTypeName(getMethod.ReturnType.ToString());

                            writer.AppendLineInvariant($@"bindableType.AddProperty(""{propertyName}"", typeof({propertyType}),  Get{propertyName}, Set{propertyName});");

                            postWriter.AppendLineInvariant($@"private static object Get{propertyName}(object instance,  Windows.UI.Xaml.DependencyPropertyValuePrecedences? precedence) => {getter};");
                            postWriter.AppendLineInvariant($@"private static void Set{propertyName}(object instance, object value, Windows.UI.Xaml.DependencyPropertyValuePrecedences? precedence) => {setter};");
                        }
                    }

                    writer.AppendLineInvariant(@"return bindableType;");
                }

                writer.Append(postWriter.ToString());
            }

            writer.AppendLine();
        }
        private void GenerateProviderTable(IEnumerable <INamedTypeSymbol> q, IndentedStringBuilder writer)
        {
            writer.AppendLineInvariant("[System.Runtime.CompilerServices.CompilerGeneratedAttribute]");
            writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1502:AvoidExcessiveComplexity\", Justification=\"Must be ignored even if generated code is checked.\")]");
            writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1506:AvoidExcessiveClassCoupling\", Justification = \"Must be ignored even if generated code is checked.\")]");

            AnalyzerSuppressionsGenerator.Generate(writer, AnalyzerSuppressions);
            using (writer.BlockInvariant("public class BindableMetadataProvider : global::Uno.UI.DataBinding.IBindableMetadataProvider"))
            {
                writer.AppendLineInvariant(@"static global::System.Collections.Hashtable _bindableTypeCacheByFullName = new global::System.Collections.Hashtable({0});", q.Count());

                writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1502:AvoidExcessiveComplexity\", Justification=\"Must be ignored even if generated code is checked.\")]");
                writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1506:AvoidExcessiveClassCoupling\", Justification = \"Must be ignored even if generated code is checked.\")]");
                writer.AppendLineInvariant("[System.Diagnostics.CodeAnalysis.SuppressMessage(\"Microsoft.Maintainability\", \"CA1505:AvoidUnmaintainableCode\", Justification = \"Must be ignored even if generated code is checked.\")]");

                writer.AppendLineInvariant("private delegate global::Uno.UI.DataBinding.IBindableType TypeBuilderDelegate();");

                using (writer.BlockInvariant("private static TypeBuilderDelegate CreateMemoized(TypeBuilderDelegate builder)"))
                {
                    writer.AppendLineInvariant(@"global::Uno.UI.DataBinding.IBindableType value = null;
						return () => {{
							if (value == null)
							{{
								value = builder();
							}}

							return value;
						}};"
                                               );
                }

                using (writer.BlockInvariant("static BindableMetadataProvider()"))
                {
                    GenerateTypeTable(writer, q);
                }

                writer.AppendLineInvariant(@"#if DEBUG");
                writer.AppendLineInvariant(@"private global::System.Collections.Generic.List<global::System.Type> _knownMissingTypes = new global::System.Collections.Generic.List<global::System.Type>();");
                writer.AppendLineInvariant(@"#endif");

                using (writer.BlockInvariant("public void ForceInitialize()"))
                {
                    using (writer.BlockInvariant(@"foreach(TypeBuilderDelegate item in _bindableTypeCacheByFullName.Values)"))
                    {
                        writer.AppendLineInvariant(@"item();");
                    }
                }

                using (writer.BlockInvariant("public global::Uno.UI.DataBinding.IBindableType GetBindableTypeByFullName(string fullName)"))
                {
                    writer.AppendLineInvariant(@"var selector = _bindableTypeCacheByFullName[fullName] as TypeBuilderDelegate;");

                    using (writer.BlockInvariant(@"if(selector != null)"))
                    {
                        writer.AppendLineInvariant(@"return selector();");
                    }
                    using (writer.BlockInvariant(@"else"))
                    {
                        writer.AppendLineInvariant(@"return null;");
                    }
                }

                using (writer.BlockInvariant("public global::Uno.UI.DataBinding.IBindableType GetBindableTypeByType(Type type)"))
                {
                    writer.AppendLineInvariant(@"var selector = _bindableTypeCacheByFullName[type.FullName] as TypeBuilderDelegate;");

                    using (writer.BlockInvariant(@"if(selector != null)"))
                    {
                        writer.AppendLineInvariant(@"return selector();");
                    }

                    writer.AppendLineInvariant(@"#if DEBUG");
                    using (writer.BlockInvariant(@"else"))
                    {
                        using (writer.BlockInvariant(@"lock(_knownMissingTypes)"))
                        {
                            using (writer.BlockInvariant(@"if(!_knownMissingTypes.Contains(type) || !type.IsGenericType)"))
                            {
                                writer.AppendLineInvariant(@"_knownMissingTypes.Add(type);");
                                writer.AppendLineInvariant(@"Debug.WriteLine($""The Bindable attribute is missing and the type [{{type.FullName}}] is not known by the MetadataProvider. Reflection was used instead of the binding engine and generated static metadata. Add the Bindable attribute to prevent this message and performance issues."");");
                            }
                        }
                    }
                    writer.AppendLineInvariant(@"#endif");

                    writer.AppendLineInvariant(@"return null;");
                }
            }
        }
Exemple #3
0
        private string GenerateGlobalResources(IEnumerable <XamlFileDefinition> files)
        {
            var outputFile = Path.Combine(_targetPath, "GlobalStaticResources.g.cs");

            var writer = new IndentedStringBuilder();

            writer.AppendLineInvariant("// <autogenerated />");
            writer.AppendLineInvariant("#pragma warning disable 618 // Ignore obsolete members warnings");
            writer.AppendLineInvariant("#pragma warning disable 105 // Ignore duplicate namespaces");
            writer.AppendLineInvariant("using System;");
            writer.AppendLineInvariant("using System.Linq;");
            writer.AppendLineInvariant("using System.Collections.Generic;");
            writer.AppendLineInvariant("using Uno.Extensions;");
            writer.AppendLineInvariant("using Uno;");
            writer.AppendLineInvariant("using System.Diagnostics;");

            //TODO Determine the list of namespaces to use
            writer.AppendLineInvariant($"using {XamlConstants.BaseXamlNamespace};");
            writer.AppendLineInvariant($"using {XamlConstants.Namespaces.Controls};");
            writer.AppendLineInvariant($"using {XamlConstants.Namespaces.Data};");
            writer.AppendLineInvariant($"using {XamlConstants.Namespaces.Documents};");
            writer.AppendLineInvariant($"using {XamlConstants.Namespaces.Media};");
            writer.AppendLineInvariant($"using {XamlConstants.Namespaces.MediaAnimation};");
            writer.AppendLineInvariant("using {0};", _defaultNamespace);
            writer.AppendLineInvariant("");

            using (writer.BlockInvariant("namespace {0}", _defaultNamespace))
            {
                writer.AppendLineInvariant("/// <summary>");
                writer.AppendLineInvariant("/// Contains all the static resources defined for the application");
                writer.AppendLineInvariant("/// </summary>");

                AnalyzerSuppressionsGenerator.Generate(writer, _analyzerSuppressions);
                using (writer.BlockInvariant("public sealed partial class GlobalStaticResources"))
                {
                    writer.AppendLineInvariant("static bool _initialized;");

                    using (writer.BlockInvariant("static GlobalStaticResources()"))
                    {
                        writer.AppendLineInvariant("Initialize();");
                    }

                    using (writer.BlockInvariant("public static void Initialize()"))
                    {
                        using (writer.BlockInvariant("if(!_initialized)"))
                        {
                            writer.AppendLineInvariant("_initialized = true;");

                            foreach (var ambientResource in _ambientGlobalResources)
                            {
                                if (ambientResource.GetMethods().Any(m => m.Name == "Initialize"))
                                {
                                    writer.AppendLineInvariant("global::{0}.Initialize();", ambientResource.GetFullName());
                                }

                                writer.AppendLineInvariant("AddResolver(global::{0}.FindResource);", ambientResource.GetFullName());
                            }

                            foreach (var file in files)
                            {
                                writer.AppendLineInvariant("RegisterResources_{0}();", file.UniqueID);
                                writer.AppendLineInvariant("RegisterImplicitStylesResources_{0}();", file.UniqueID);
                            }
                        }
                    }

                    // Generate all the partial methods, even if they don't exist. That avoids
                    // having to sync the generation of the files with this global table.
                    foreach (var file in files)
                    {
                        writer.AppendLineInvariant("static partial void RegisterResources_{0}();", file.UniqueID);
                        writer.AppendLineInvariant("static partial void RegisterImplicitStylesResources_{0}();", file.UniqueID);
                    }

                    writer.AppendLineInvariant("");

                    writer.AppendLineInvariant("/// <summary>");
                    writer.AppendLineInvariant("/// Finds a resource instance in the Global Static Resources");
                    writer.AppendLineInvariant("/// </summary>");
                    writer.AppendLineInvariant("/// <param name=\"name\">The name of the resource</param>");
                    writer.AppendLineInvariant("/// <returns>The instance of the resources, otherwise null.</returns>");
                    using (writer.BlockInvariant("public static object FindResource(string name)"))
                    {
                        using (writer.BlockInvariant("foreach(var resolver in _resolvers)"))
                        {
                            writer.AppendLineInvariant("var resource = resolver(name);");
                            writer.AppendLineInvariant("if(resource != null){{ return resource; }}");
                        }
                        writer.AppendLineInvariant("return null;");
                    }

                    writer.AppendLineInvariant("");

                    writer.AppendLineInvariant("private static List<Func<string, object>> _resolvers = new List<Func<string, object>>();");

                    using (writer.BlockInvariant("private static void AddResolver(Func<string, object> resolver)"))
                    {
                        writer.AppendLineInvariant("_resolvers.Add(resolver);");
                    }
                }
            }

            return(writer.ToString());
        }
        private string GenerateGlobalResources(IEnumerable <XamlFileDefinition> files, XamlGlobalStaticResourcesMap map)
        {
            var outputFile = Path.Combine(_targetPath, "GlobalStaticResources.g.cs");

            var writer = new IndentedStringBuilder();

            writer.AppendLineInvariant("// <autogenerated />");
            writer.AppendLineInvariant("#pragma warning disable 618  // Ignore obsolete members warnings");
            writer.AppendLineInvariant("#pragma warning disable 105  // Ignore duplicate namespaces");
            writer.AppendLineInvariant("#pragma warning disable 1591 // Ignore missing XML comment warnings");
            writer.AppendLineInvariant("using System;");
            writer.AppendLineInvariant("using System.Linq;");
            writer.AppendLineInvariant("using System.Collections.Generic;");
            writer.AppendLineInvariant("using Uno.Extensions;");
            writer.AppendLineInvariant("using Uno;");
            writer.AppendLineInvariant("using System.Diagnostics;");

            //TODO Determine the list of namespaces to use
            writer.AppendLineInvariant($"using {XamlConstants.BaseXamlNamespace};");
            writer.AppendLineInvariant($"using {XamlConstants.Namespaces.Controls};");
            writer.AppendLineInvariant($"using {XamlConstants.Namespaces.Data};");
            writer.AppendLineInvariant($"using {XamlConstants.Namespaces.Documents};");
            writer.AppendLineInvariant($"using {XamlConstants.Namespaces.Media};");
            writer.AppendLineInvariant($"using {XamlConstants.Namespaces.MediaAnimation};");
            writer.AppendLineInvariant("using {0};", _defaultNamespace);
            writer.AppendLineInvariant("");

            using (writer.BlockInvariant("namespace {0}", _defaultNamespace))
            {
                writer.AppendLineInvariant("/// <summary>");
                writer.AppendLineInvariant("/// Contains all the static resources defined for the application");
                writer.AppendLineInvariant("/// </summary>");

                AnalyzerSuppressionsGenerator.Generate(writer, _analyzerSuppressions);
                using (writer.BlockInvariant("public sealed partial class GlobalStaticResources"))
                {
                    writer.AppendLineInvariant("static bool _initialized;");
                    writer.AppendLineInvariant("private static bool _stylesRegistered;");
                    writer.AppendLineInvariant("private static bool _dictionariesRegistered;");

                    using (writer.BlockInvariant("internal static {0} {1} {{get; }} = new {0}()", ParseContextPropertyType, ParseContextPropertyName))
                    {
                        writer.AppendLineInvariant("AssemblyName = \"{0}\",", _projectInstance.GetPropertyValue("AssemblyName"));
                    }

                    writer.AppendLineInvariant(";");
                    writer.AppendLine();

                    using (writer.BlockInvariant("static GlobalStaticResources()"))
                    {
                        writer.AppendLineInvariant("Initialize();");
                    }

                    using (writer.BlockInvariant("public static void Initialize()"))
                    {
                        using (writer.BlockInvariant("if (!_initialized)"))
                        {
                            using (IsUnoAssembly ? writer.BlockInvariant("using (ResourceResolver.WriteInitiateGlobalStaticResourcesEventActivity())") : null)
                            {
                                writer.AppendLineInvariant("_initialized = true;");

                                foreach (var ambientResource in _ambientGlobalResources)
                                {
                                    if (ambientResource.GetMethods().Any(m => m.Name == "Initialize"))
                                    {
                                        writer.AppendLineInvariant("global::{0}.Initialize();", ambientResource.GetFullName());
                                    }
                                }

                                foreach (var ambientResource in _ambientGlobalResources)
                                {
                                    // Note: we do *not* call RegisterDefaultStyles for the current assembly, because those styles are treated as implicit styles, not default styles
                                    if (ambientResource.GetMethods().Any(m => m.Name == "RegisterDefaultStyles"))
                                    {
                                        writer.AppendLineInvariant("global::{0}.RegisterDefaultStyles();", ambientResource.GetFullName());
                                    }
                                }

                                foreach (var ambientResource in _ambientGlobalResources)
                                {
                                    if (ambientResource.GetMethods().Any(m => m.Name == "RegisterResourceDictionariesBySource"))
                                    {
                                        writer.AppendLineInvariant("global::{0}.RegisterResourceDictionariesBySource();", ambientResource.GetFullName());
                                    }
                                }

                                if (IsUnoAssembly && _xamlSourceFiles.Any())
                                {
                                    // Build master dictionary
                                    foreach (var dictProperty in map.GetAllDictionaryProperties(_baseResourceDependencies, _nonSystemResources))
                                    {
                                        writer.AppendLineInvariant("MasterDictionary.MergedDictionaries.Add({0});", dictProperty);
                                    }
                                }
                            }
                        }
                    }

                    using (writer.BlockInvariant("public static void RegisterDefaultStyles()"))
                    {
                        using (writer.BlockInvariant("if(!_stylesRegistered)"))
                        {
                            writer.AppendLineInvariant("_stylesRegistered = true;");
                            foreach (var file in files.Where(f => IsIncludedResource(f, map)).Select(f => f.UniqueID).Distinct())
                            {
                                writer.AppendLineInvariant("RegisterDefaultStyles_{0}();", file);
                            }
                        }
                    }

                    writer.AppendLineInvariant("// Register ResourceDictionaries using ms-appx:/// syntax, this is called for external resources");
                    using (writer.BlockInvariant("public static void RegisterResourceDictionariesBySource()"))
                    {
                        using (writer.BlockInvariant("if(!_dictionariesRegistered)"))
                        {
                            writer.AppendLineInvariant("_dictionariesRegistered = true;");

                            if (!IsUnoAssembly && !IsUnoFluentAssembly)
                            {
                                // For third-party libraries, expose all files using standard uri
                                foreach (var file in files.Where(IsResourceDictionary))
                                {
                                    var url = "{0}/{1}".InvariantCultureFormat(_metadataHelper.AssemblyName, map.GetSourceLink(file));
                                    RegisterForFile(file, url);
                                }
                            }
                            else if (files.Any())                             // The NETSTD reference assembly contains no Xaml files
                            {
                                // For Uno assembly, we expose WinUI resources using same uri as on Windows
                                RegisterForFile(files.FirstOrDefault(f => map.GetSourceLink(f).EndsWith(WinUIThemeResourcePathSuffix)), XamlFilePathHelper.WinUIThemeResourceURL);
                                RegisterForFile(files.FirstOrDefault(f => map.GetSourceLink(f).EndsWith(WinUICompactPathSuffix)), XamlFilePathHelper.WinUICompactURL);
                            }

                            void RegisterForFile(XamlFileDefinition file, string url)
                            {
                                if (file != null)
                                {
                                    writer.AppendLineInvariant("global::Uno.UI.ResourceResolver.RegisterResourceDictionaryBySource(uri: \"ms-appx:///{0}\", context: {1}, dictionary: () => {2}_ResourceDictionary);",
                                                               url,
                                                               ParseContextPropertyName,
                                                               file.UniqueID
                                                               );
                                }
                            }
                        }
                    }

                    writer.AppendLineInvariant("// Register ResourceDictionaries using ms-resource:/// syntax, this is called for local resources");
                    using (writer.BlockInvariant("internal static void RegisterResourceDictionariesBySourceLocal()"))
                    {
                        foreach (var file in files.Where(IsResourceDictionary))
                        {
                            // We leave context null because local resources should be found through Application.Resources
                            writer.AppendLineInvariant("global::Uno.UI.ResourceResolver.RegisterResourceDictionaryBySource(uri: \"{0}{1}\", context: null, dictionary: () => {2}_ResourceDictionary);",
                                                       XamlFilePathHelper.LocalResourcePrefix,
                                                       map.GetSourceLink(file),
                                                       file.UniqueID
                                                       );
                            // Local resources can also be found through the ms-appx:/// prefix
                            writer.AppendLineInvariant("global::Uno.UI.ResourceResolver.RegisterResourceDictionaryBySource(uri: \"{0}{1}\", context: null, dictionary: () => {2}_ResourceDictionary);",
                                                       XamlFilePathHelper.AppXIdentifier,
                                                       map.GetSourceLink(file),
                                                       file.UniqueID
                                                       );
                        }
                    }

                    if (IsUnoAssembly)
                    {
                        // Declare master dictionary
                        writer.AppendLine();
                        writer.AppendLineInvariant("internal static ResourceDictionary MasterDictionary {{get; }} = new ResourceDictionary();");
                    }

                    // Generate all the partial methods, even if they don't exist. That avoids
                    // having to sync the generation of the files with this global table.
                    foreach (var file in files.Select(f => f.UniqueID).Distinct())
                    {
                        writer.AppendLineInvariant("static partial void RegisterDefaultStyles_{0}();", file);
                    }

                    writer.AppendLineInvariant("[global::System.Obsolete(\"This method is provided for binary backward compatibility. It will always return null.\")]");
                    writer.AppendLineInvariant("[global::System.ComponentModel.EditorBrowsable(global::System.ComponentModel.EditorBrowsableState.Never)]");
                    writer.AppendLineInvariant("public static object FindResource(string name) => null;");

                    writer.AppendLineInvariant("");
                }
            }

            return(writer.ToString());
        }
            private void ProcessType(INamedTypeSymbol typeSymbol)
            {
                _context.CancellationToken.ThrowIfCancellationRequested();

                if (typeSymbol.TypeKind != TypeKind.Class)
                {
                    return;
                }

                var isDependencyObject = typeSymbol.Interfaces.Any(t => SymbolEqualityComparer.Default.Equals(t, _dependencyObjectSymbol)) &&
                                         (typeSymbol.BaseType?.GetAllInterfaces().None(t => SymbolEqualityComparer.Default.Equals(t, _dependencyObjectSymbol)) ?? true);

                if (isDependencyObject)
                {
                    if (!_isUnoSolution)
                    {
                        if (typeSymbol.Is(_iosViewSymbol))
                        {
                            throw new InvalidOperationException("A 'UIKit.UIView' shouldn't implement 'DependencyObject'. Inherit 'FrameworkElement' instead.");
                        }
                        else if (typeSymbol.Is(_androidViewSymbol))
                        {
                            throw new InvalidOperationException("An 'Android.Views.View' shouldn't implement 'DependencyObject'. Inherit 'FrameworkElement' instead.");
                        }
                        else if (typeSymbol.Is(_macosViewSymbol))
                        {
                            throw new InvalidOperationException("An 'AppKit.NSView' shouldn't implement 'DependencyObject'. Inherit 'FrameworkElement' instead.");
                        }
                    }

                    var builder = new IndentedStringBuilder();
                    builder.AppendLineInvariant("// <auto-generated>");
                    builder.AppendLineInvariant("// ******************************************************************");
                    builder.AppendLineInvariant("// This file has been generated by Uno.UI (DependencyObjectGenerator)");
                    builder.AppendLineInvariant("// ******************************************************************");
                    builder.AppendLineInvariant("// </auto-generated>");
                    builder.AppendLine();
                    builder.AppendLineInvariant("#pragma warning disable 1591 // Ignore missing XML comment warnings");
                    builder.AppendLineInvariant($"using System;");
                    builder.AppendLineInvariant($"using System.Linq;");
                    builder.AppendLineInvariant($"using System.Collections.Generic;");
                    builder.AppendLineInvariant($"using System.Collections;");
                    builder.AppendLineInvariant($"using System.Diagnostics.CodeAnalysis;");
                    builder.AppendLineInvariant($"using Uno.Disposables;");
                    builder.AppendLineInvariant($"using System.Runtime.CompilerServices;");
                    builder.AppendLineInvariant($"using Uno.UI;");
                    builder.AppendLineInvariant($"using Uno.UI.Controls;");
                    builder.AppendLineInvariant($"using Uno.UI.DataBinding;");
                    builder.AppendLineInvariant($"using Windows.UI.Xaml;");
                    builder.AppendLineInvariant($"using Windows.UI.Xaml.Data;");
                    builder.AppendLineInvariant($"using Uno.Diagnostics.Eventing;");
                    builder.AppendLineInvariant("#if __MACOS__");
                    builder.AppendLineInvariant("using AppKit;");
                    builder.AppendLineInvariant("#endif");

                    using (builder.BlockInvariant($"namespace {typeSymbol.ContainingNamespace}"))
                    {
                        using (GenerateNestingContainers(builder, typeSymbol))
                        {
                            if (_bindableAttributeSymbol != null && typeSymbol.FindAttribute(_bindableAttributeSymbol) == null)
                            {
                                builder.AppendLineInvariant(@"[global::Windows.UI.Xaml.Data.Bindable]");
                            }

                            AnalyzerSuppressionsGenerator.Generate(builder, _analyzerSuppressions);

                            var internalDependencyObject = _isUnoSolution && !typeSymbol.IsSealed ? ", IDependencyObjectInternal" : "";

                            using (builder.BlockInvariant($"partial class {typeSymbol.Name} : IDependencyObjectStoreProvider, IWeakReferenceProvider{internalDependencyObject}"))
                            {
                                GenerateDependencyObjectImplementation(typeSymbol, builder);
                                GenerateIBinderImplementation(typeSymbol, builder);
                            }
                        }
                    }

                    _context.AddSource(HashBuilder.BuildIDFromSymbol(typeSymbol), builder.ToString());
                }
            }