Exemplo n.º 1
0
        static MSBuildLanguageElement AddBuiltin(string name, string description, MSBuildKind kind, MSBuildValueKind valueKind = MSBuildValueKind.Nothing, bool isAbstract = false)
        {
            var el = new MSBuildLanguageElement(name, description, kind, valueKind, isAbstract);

            builtin.Add(el.Name, el);
            return(el);
        }
        public static IEnumerable <BaseInfo> GetElementCompletions(this MSBuildResolveResult rr, IEnumerable <IMSBuildSchema> schemas)
        {
            if (rr?.LanguageElement == null)
            {
                yield return(MSBuildLanguageElement.Get("Project"));

                yield break;
            }

            if (rr.LanguageElement.Children == null)
            {
                yield break;
            }

            foreach (var c in rr.LanguageElement.Children)
            {
                if (c.IsAbstract)
                {
                    var abstractChildren = GetAbstractChildren(schemas, rr.LanguageElement.AbstractChild.Kind, rr.ElementName);
                    if (abstractChildren != null)
                    {
                        foreach (var child in abstractChildren)
                        {
                            yield return(child);
                        }
                    }
                }
                else
                {
                    yield return(c);
                }
            }
        }
Exemplo n.º 3
0
        public static MSBuildLanguageElement Get(string name, MSBuildLanguageElement parent = null)
        {
            if (parent != null)
            {
                foreach (var child in parent.children)
                {
                    if (string.Equals(child.Name, name, StringComparison.OrdinalIgnoreCase))
                    {
                        return(child);
                    }
                }
                return(parent.AbstractChild);
            }

            builtin.TryGetValue(name, out MSBuildLanguageElement result);
            return(result);
        }
        public static bool IsInTarget(this MSBuildLanguageElement resolvedElement, Xml.Dom.XElement element)
        {
            switch (resolvedElement.Kind)
            {
            case MSBuildKind.Metadata:
                element = element?.ParentElement();
                goto case MSBuildKind.Item;

            case MSBuildKind.Property:
            case MSBuildKind.Item:
                element = element?.ParentElement();
                goto case MSBuildKind.ItemGroup;

            case MSBuildKind.ItemGroup:
            case MSBuildKind.PropertyGroup:
                var name = element?.ParentElement()?.Name.Name;
                return(string.Equals(name, "Target", StringComparison.OrdinalIgnoreCase));
            }
            return(false);
        }
Exemplo n.º 5
0
        public static ValueInfo GetElementInfo(this IEnumerable <IMSBuildSchema> schemas, MSBuildLanguageElement element, string parentName, string elementName, bool omitEmpty = false)
        {
            if (element.IsAbstract)
            {
                switch (element.Kind)
                {
                case MSBuildKind.Item:
                case MSBuildKind.ItemDefinition:
                    if (omitEmpty)
                    {
                        return(null);
                    }
                    return(schemas.GetItem(elementName));

                case MSBuildKind.Metadata:
                    return(schemas.GetMetadata(parentName, elementName, false));

                case MSBuildKind.Property:
                    return(schemas.GetProperty(elementName));

                case MSBuildKind.Parameter:
                    if (omitEmpty)
                    {
                        return(null);
                    }
                    return(new TaskParameterInfo(elementName, null, false, false, MSBuildValueKind.Unknown));

                default:
                    throw new InvalidOperationException($"Unsupported abstract element kind {element.Kind}");
                }
            }

            if (omitEmpty && (element.ValueKind == MSBuildValueKind.Nothing || element.ValueKind == MSBuildValueKind.Data))
            {
                return(null);
            }
            return(element);
        }