void AnalyzePropertyPathProperty(PropertyPathPartUpdater part)
        {
            // This is a property reference. This may be directly the name of a property or a reference by
            // with the type to the property
            // Simple Property:    "TestProperty"
            // Property with Type: "(local:DataClass.TestProperty)"

            var typeName     = part.GetTypeName();
            var propertyName = part.GetPropertyName();

            if (!string.IsNullOrWhiteSpace(typeName))
            {
                var sig = ResolveType(typeName, out var prefix);
                if (sig != null && context.Modules.Contains((ModuleDefMD)sig.ToBasicTypeDefOrRef().ResolveTypeDefThrow().Module))
                {
                    var reference = new BAMLPathTypeReference(xmlnsCtx, sig, part);
                    AddTypeSigReference(sig, reference);
                    return;
                }
            }

            // Reaching this point means that the type reference was either not present or failed to
            // resolve. In this case every property with the matching name will be flagged so it does not
            // get renamed.
            if (properties.TryGetValue(propertyName, out var candidates))
            {
                foreach (var property in candidates)
                {
                    service.SetCanRename(property, false);
                }
            }
        }
        void AnalyzePropertyPath(string path)
        {
            var propertyPath = new PropertyPath(path);

            foreach (PropertyPathPart part in propertyPath.Parts)
            {
                if (part.IsAttachedDP())
                {
                    string type, property;
                    part.ExtractAttachedDP(out type, out property);
                    if (type != null)
                    {
                        string  prefix;
                        TypeSig sig = ResolveType(type, out prefix);
                        if (sig != null && context.Modules.Contains((ModuleDefMD)sig.ToBasicTypeDefOrRef().ResolveTypeDefThrow().Module))
                        {
                            var reference = new BAMLPathTypeReference(xmlnsCtx, sig, part);
                            AddTypeSigReference(sig, reference);
                        }
                    }
                }
                else
                {
                    List <PropertyDef> candidates;
                    if (properties.TryGetValue(part.Name, out candidates))
                    {
                        foreach (PropertyDef property in candidates)
                        {
                            if (!parameters.GetParameter(context, property, "forceRen", false))
                            {
                                service.SetCanRename(property, false, "It is potentially used for XAML bindings");
                            }
                        }
                    }
                }

                if (part.IndexerArguments != null)
                {
                    foreach (PropertyPathIndexer indexer in part.IndexerArguments)
                    {
                        if (!string.IsNullOrEmpty(indexer.Type))
                        {
                            string  prefix;
                            TypeSig sig = ResolveType(indexer.Type, out prefix);
                            if (sig != null && context.Modules.Contains((ModuleDefMD)sig.ToBasicTypeDefOrRef().ResolveTypeDefThrow().Module))
                            {
                                var reference = new BAMLPathTypeReference(xmlnsCtx, sig, part);
                                AddTypeSigReference(sig, reference);
                            }
                        }
                    }
                }
            }
        }
 void AnalyzePropertyPathIndexer(PropertyPathPartUpdater part)
 {
     foreach (var indexerArg in part.ParamList)
     {
         if (!string.IsNullOrWhiteSpace(indexerArg.ParenString))
         {
             var sig = ResolveType(indexerArg.ParenString, out var prefix);
             if (sig != null && context.Modules.Contains((ModuleDefMD)sig.ToBasicTypeDefOrRef().ResolveTypeDefThrow().Module))
             {
                 var reference = new BAMLPathTypeReference(xmlnsCtx, sig, indexerArg);
                 AddTypeSigReference(sig, reference);
                 break;
             }
         }
     }
 }
Beispiel #4
0
        void AnalyzePropertyPath(string path)
        {
            var propertyPath = new PropertyPath(path);

            foreach (var part in propertyPath.Parts)
            {
                if (part.IsAttachedDP())
                {
                    part.ExtractAttachedDP(out var type, out var property);
                    if (type != null)
                    {
                        var sig = ResolveType(type, out var prefix);
                        if (sig != null && context.Modules.Contains((ModuleDefMD)sig.ToBasicTypeDefOrRef().ResolveTypeDefThrow().Module))
                        {
                            var reference = new BAMLPathTypeReference(xmlnsCtx, sig, part);
                            AddTypeSigReference(sig, reference);
                        }
                    }
                }
                else
                {
                    if (properties.TryGetValue(part.Name, out var candidates))
                    {
                        foreach (var property in candidates)
                        {
                            service.SetCanRename(property, false);
                        }
                    }
                }

                if (part.IndexerArguments != null)
                {
                    foreach (var indexer in part.IndexerArguments)
                    {
                        if (!string.IsNullOrEmpty(indexer.Type))
                        {
                            var sig = ResolveType(indexer.Type, out var prefix);
                            if (sig != null && context.Modules.Contains((ModuleDefMD)sig.ToBasicTypeDefOrRef().ResolveTypeDefThrow().Module))
                            {
                                var reference = new BAMLPathTypeReference(xmlnsCtx, sig, part);
                                AddTypeSigReference(sig, reference);
                            }
                        }
                    }
                }
            }
        }
Beispiel #5
0
        private void AnalyzePropertyPath(string path)
        {
            var propertyPath = new PropertyPath(path);
            foreach (PropertyPathPart part in propertyPath.Parts) {
                if (part.IsAttachedDP()) {
                    string type, property;
                    part.ExtractAttachedDP(out type, out property);
                    if (type != null) {
                        string prefix;
                        TypeSig sig = ResolveType(type, out prefix);
                        if (sig != null && context.Modules.Contains((ModuleDefMD)sig.ToBasicTypeDefOrRef().ResolveTypeDefThrow().Module)) {
                            var reference = new BAMLPathTypeReference(xmlnsCtx, sig, part);
                            AddTypeSigReference(sig, reference);
                        }
                    }
                }
                else {
                    List<PropertyDef> candidates;
                    if (properties.TryGetValue(part.Name, out candidates))
                        foreach (PropertyDef property in candidates) {
                            service.SetCanRename(property, false);
                        }
                }

                if (part.IndexerArguments != null) {
                    foreach (PropertyPathIndexer indexer in part.IndexerArguments)
                        if (!string.IsNullOrEmpty(indexer.Type)) {
                            string prefix;
                            TypeSig sig = ResolveType(indexer.Type, out prefix);
                            if (sig != null && context.Modules.Contains((ModuleDefMD)sig.ToBasicTypeDefOrRef().ResolveTypeDefThrow().Module)) {
                                var reference = new BAMLPathTypeReference(xmlnsCtx, sig, part);
                                AddTypeSigReference(sig, reference);
                            }
                        }
                }
            }
        }