public static void EnumChildren(ICompletionDataGenerator cdgen,ResolutionContext ctxt, UserDefinedType udt, bool isVarInstance, 
			MemberFilter vis = MemberFilter.Methods | MemberFilter.Types | MemberFilter.Variables | MemberFilter.Enums)
        {
            var scan = new MemberCompletionEnumeration(ctxt, cdgen) { isVarInst = isVarInstance };

            scan.DeepScanClass(udt, vis);
        }
        public static void EnumChildren(ICompletionDataGenerator cdgen,ResolutionContext ctxt, UserDefinedType udt, 
			MemberFilter vis = MemberFilter.Methods | MemberFilter.Types | MemberFilter.Variables | MemberFilter.Enums)
        {
            vis ^= MemberFilter.TypeParameters;

            var scan = new MemberCompletionEnumeration(ctxt, cdgen) { isVarInst = udt.NonStaticAccess };

            scan.DeepScanClass(udt, vis);
        }
Example #3
0
        public static bool IsImplicitlyConvertible(UserDefinedType r, UserDefinedType target)
        {
            if (r == null || target == null)
            {
                return(false);
            }

            if (r.Definition == target.Definition)
            {
                return(true);
            }

            if (r.Base != null && IsImplicitlyConvertible(r.Base, target))
            {
                return(true);
            }

            if (r is TemplateIntermediateType)
            {
                var templateType = (TemplateIntermediateType)r;

                if (templateType.BaseInterfaces != null &&
                    templateType.BaseInterfaces.Length != 0 &&
                    target is InterfaceType)
                {
                    foreach (var I in templateType.BaseInterfaces)
                    {
                        if (IsImplicitlyConvertible(I, target))
                        {
                            return(true);
                        }
                    }
                }
            }

            return(false);
        }
			public static bool ScanForConstructors(NewExpression sr, IBlockNode scope, UserDefinedType udt, List<AbstractType> _ctors, out bool explicitCtorFound)
			{
				explicitCtorFound = false;
				var ct = new CtorScan(sr, new ResolutionContext(new Misc.LegacyParseCacheView(new RootPackage[] {}), null, scope));
				ct.DeepScanClass(udt, new ItemCheckParameters(MemberFilter.Methods), false);

				_ctors.AddRange(ct.matches_types);

				var rawList = (udt.Definition as DClassLike)[DMethod.ConstructorIdentifierHash];
				if(rawList != null)
				{
					foreach(var n in rawList)
					{
						var dm = n as DMethod;
						if(dm == null || dm.IsStatic || dm.SpecialType != DMethod.MethodType.Constructor)
							continue;

						explicitCtorFound = true;
						break;
					}
				}

				return ct.matches_types.Count != 0;
			}
Example #5
0
        public static bool IsImplicitlyConvertible(UserDefinedType r, UserDefinedType target)
        {
            if (r == null || target == null)
                return false;

            if (r.Definition == target.Definition)
                return true;

            if (r.Base != null && IsImplicitlyConvertible(r.Base, target))
                return true;

            if (r is TemplateIntermediateType)
            {
                var templateType = (TemplateIntermediateType)r;

                if (templateType.BaseInterfaces != null &&
                    templateType.BaseInterfaces.Length != 0 &&
                    target is InterfaceType)
                {
                    foreach (var I in templateType.BaseInterfaces)
                        if (IsImplicitlyConvertible(I, target))
                            return true;
                }
            }

            return false;
        }
        void BuildCompletionData(UserDefinedType tr, ItemVisibility visMod)
        {
            var n = tr.Definition;
            if (n is DClassLike) // Add public static members of the class and including all base classes
            {
                var propertyMethodsToIgnore = new List<string>();

                var curlevel = tr;
                var tvisMod = visMod;
                while (curlevel != null)
                {
                    foreach (var i in curlevel.Definition as DBlockNode)
                    {
                        var dn = i as DNode;

                        if (i != null && dn == null)
                        {
                            CompletionDataGenerator.Add(i);
                            continue;
                        }

                        bool add = false;

                        if (tvisMod.HasFlag(ItemVisibility.All))
                            add = true;
                        else
                        {
                            if (tvisMod.HasFlag(ItemVisibility.ProtectedMembers))
                                add |= dn.ContainsAttribute(DTokens.Protected);
                            if (tvisMod.HasFlag(ItemVisibility.ProtectedStaticMembers))
                                add |= dn.ContainsAttribute(DTokens.Protected) && (dn.IsStatic || IsTypeNode(i));
                            if (tvisMod.HasFlag(ItemVisibility.PublicMembers))
                                add |= dn.IsPublic;
                            if (tvisMod.HasFlag(ItemVisibility.PublicStaticMembers))
                                add |= dn.IsPublic && (dn.IsStatic || IsTypeNode(i));
                            if (tvisMod.HasFlag(ItemVisibility.StaticMembers))
                                add |= dn.IsStatic || IsTypeNode(i);
                        }

                        if (add)
                        {
                            if (CanItemBeShownGenerally(dn))
                            {
                                // Convert @property getters&setters to one unique property
                                if (dn is DMethod && dn.ContainsPropertyAttribute())
                                {
                                    if (!propertyMethodsToIgnore.Contains(dn.Name))
                                    {
                                        var dm = dn as DMethod;
                                        bool isGetter = dm.Parameters.Count < 1;

                                        var virtPropNode = new DVariable();

                                        virtPropNode.AssignFrom(dn);

                                        if (!isGetter)
                                            virtPropNode.Type = dm.Parameters[0].Type;

                                        CompletionDataGenerator.Add(virtPropNode);

                                        propertyMethodsToIgnore.Add(dn.Name);
                                    }
                                }
                                else
                                    CompletionDataGenerator.Add(dn);
                            }

                            // Add members of anonymous enums
                            else if (dn is DEnum && string.IsNullOrEmpty(dn.Name))
                            {
                                foreach (var k in dn as DEnum)
                                    CompletionDataGenerator.Add(k);
                            }
                        }
                    }
                    curlevel = curlevel.Base as UserDefinedType;

                    // After having shown all items on the current node level,
                    // allow showing public (static) and/or protected items in the more basic levels then
                    if (tvisMod.HasFlag(ItemVisibility.All))
                    {
                        if ((n as DClassLike).ContainsAttribute(DTokens.Static))
                            tvisMod = ItemVisibility.ProtectedStaticMembers | ItemVisibility.PublicStaticMembers;
                        else
                            tvisMod = ItemVisibility.ProtectedMembers | ItemVisibility.PublicMembers;
                    }
                }
            }
            else if (n is DEnum)
            {
                var de = n as DEnum;

                foreach (var i in de)
                    if (i is DEnumValue)
                        CompletionDataGenerator.Add(i);
            }
        }
 void BuildCompletionData(UserDefinedType tr, bool showInstanceItems)
 {
     MemberCompletionEnumeration.EnumChildren(CompletionDataGenerator, ctxt, tr, showInstanceItems, MemberFilter);
     StaticProperties.ListProperties(CompletionDataGenerator, MemberFilter, tr, showInstanceItems);
 }