Пример #1
0
        public IncludeNode(DirectiveInfo info)
            : base(info)
        {
            Filename = ExpressionRewriter.Rewrite(Token.ReadTokens(info.ParametersReader));

            this.parentParser = info.Parser;
        }
Пример #2
0
        private void ProcessDirective([NotNull] IT4Directive directive)
        {
            IT4Token nameToken = directive.GetNameToken();

            if (nameToken == null)
            {
                return;
            }

            DirectiveInfo directiveInfo = _directiveInfoManager.GetDirectiveByName(nameToken.GetText());

            if (directiveInfo == null)
            {
                return;
            }

            IEnumerable <string> attributeNames = directive.GetAttributes().SelectNotNull(attr => attr.GetName());
            var hashSet = new JetHashSet <string>(attributeNames, StringComparer.OrdinalIgnoreCase);

            foreach (DirectiveAttributeInfo attributeInfo in directiveInfo.SupportedAttributes)
            {
                if (attributeInfo.IsRequired && !hashSet.Contains(attributeInfo.Name))
                {
                    AddHighlighting(new HighlightingInfo(nameToken.GetHighlightingRange(),
                                                         new MissingRequiredAttributeHighlighting(nameToken, attributeInfo.Name)));
                }
            }
        }
Пример #3
0
        private void ProcessDirective([NotNull] IT4Directive directive)
        {
            IT4Token nameToken = directive.GetNameToken();

            if (nameToken == null)
            {
                return;
            }

            DirectiveInfo directiveInfo = _directiveInfoManager.GetDirectiveByName(nameToken.GetText());

            if (directiveInfo == null)
            {
                return;
            }

            // Notify of missing required attributes.
            IEnumerable <string> attributeNames = directive.GetAttributes().SelectNotNull(attr => attr.GetName());
            var hashSet = new JetHashSet <string>(attributeNames, StringComparer.OrdinalIgnoreCase);

            foreach (DirectiveAttributeInfo attributeInfo in directiveInfo.SupportedAttributes)
            {
                if (attributeInfo.IsRequired && !hashSet.Contains(attributeInfo.Name))
                {
                    AddHighlighting(new HighlightingInfo(nameToken.GetHighlightingRange(),
                                                         new MissingRequiredAttributeHighlighting(nameToken, attributeInfo.Name)));
                }
            }

            // Assembly attributes in preprocessed templates are useless.
            if (directiveInfo == _directiveInfoManager.Assembly && DaemonProcess.SourceFile.ToProjectFile().IsPreprocessedT4Template())
            {
                AddHighlighting(new HighlightingInfo(directive.GetHighlightingRange(), new IgnoredAssemblyDirectiveHighlighting(directive)));
            }
        }
Пример #4
0
        protected override bool AddLookupItems(T4CodeCompletionContext context, IItemsCollector collector)
        {
            ITreeNode node = context.BasicContext.File.FindNodeAt(context.BasicContext.SelectedTreeRange);

            Assertion.AssertNotNull(node, "node == null");
            var ranges = context.BasicContext.GetRanges(node);

            collector.AddRanges(ranges);

            var attribute = node.GetContainingNode <IT4DirectiveAttribute>();

            Assertion.AssertNotNull(attribute, "attribute != null");

            var directive = attribute.GetContainingNode <IT4Directive>();

            Assertion.AssertNotNull(directive, "directive != null");

            DirectiveInfo          directiveInfo = _directiveInfoManager.GetDirectiveByName(directive.GetName());
            DirectiveAttributeInfo attributeInfo = directiveInfo?.GetAttributeByName(attribute.GetName());

            if (attributeInfo == null)
            {
                return(false);
            }

            foreach (string intellisenseValue in attributeInfo.IntelliSenseValues)
            {
                var item = new TextLookupItem(intellisenseValue);
                item.InitializeRanges(ranges, context.BasicContext);
                collector.Add(item);
            }

            return(true);
        }
Пример #5
0
        public LocalNode(DirectiveInfo info)
            : base(info)
        {
            VariableName = Token.ReadToken(info.ParametersReader);

            if(VariableName == null) {
                throw new MissingDataException("Expected a variable name", info.ParametersReader.Location);
            }

            if(VariableName.TokenType != TokenType.Identifier) {
                throw new BadDataException("Expected a variable name", VariableName.Location);
            }
        }
Пример #6
0
 private static string GetSortValue([NotNull] IT4Directive directive, [CanBeNull] DirectiveInfo directiveInfo,
                                    [NotNull] DirectiveInfoManager directiveInfoManager)
 {
     if (directiveInfo == directiveInfoManager.Assembly)
     {
         return(directive.GetAttributeValue(directiveInfoManager.Assembly.NameAttribute.Name));
     }
     if (directiveInfo == directiveInfoManager.Import)
     {
         return(directive.GetAttributeValue(directiveInfoManager.Import.NamespaceAttribute.Name));
     }
     if (directiveInfo == directiveInfoManager.Parameter)
     {
         return(directive.GetAttributeValue(directiveInfoManager.Parameter.NameAttribute.Name));
     }
     return(null);
 }
Пример #7
0
        public EachNode(DirectiveInfo info)
            : base(info)
        {
            Token token = Token.ReadToken(info.ParametersReader);

            if(token == null) {
                throw new MissingDataException("Variable name", info.ParametersReader.Location);
            }

            if(token.TokenType != TokenType.Identifier) {
                throw new MissingDataException("Variable name", token.Location);
            }

            Variable = token.Value.ToString();

            Values = ExpressionRewriter.Rewrite(Token.ReadTokens(info.ParametersReader));
        }
Пример #8
0
        private void ProcessAttributeValue([NotNull] T4Token valueNode)
        {
            var attribute = valueNode.Parent as IT4DirectiveAttribute;

            if (attribute == null)
            {
                return;
            }

            if (attribute.ValueError != null)
            {
                AddHighlighting(new HighlightingInfo(valueNode.GetHighlightingRange(),
                                                     new InvalidAttributeValueHighlighting(valueNode, null, attribute.ValueError)));
                return;
            }

            var directive = attribute.Parent as IT4Directive;

            if (directive == null)
            {
                return;
            }

            DirectiveInfo directiveInfo = _directiveInfoManager.GetDirectiveByName(directive.GetName());

            if (directiveInfo == null)
            {
                return;
            }

            DirectiveAttributeInfo attributeInfo = directiveInfo.GetAttributeByName(attribute.GetName());

            if (attributeInfo == null)
            {
                return;
            }

            if (attributeInfo.IsValid(valueNode.GetText()))
            {
                return;
            }

            AddHighlighting(new HighlightingInfo(valueNode.GetHighlightingRange(),
                                                 new InvalidAttributeValueHighlighting(valueNode, attributeInfo, "Invalid attribute value")));
        }
Пример #9
0
        public LetNode(DirectiveInfo info)
            : base(info)
        {
            Token token = Token.ReadToken(info.ParametersReader);

            if(token == null) {
                throw new MissingDataException("Variable name", info.ParametersReader.Location);
            }

            if(token.TokenType != TokenType.Identifier) {
                throw new MissingDataException("Variable name", token.Location);
            }

            Variable = token.Value.ToString();

            info.ParametersReader.SkipWhiteSpace();

            foreach(var node in (new Parser(info.Parser, info.ParametersReader)).ReadNodes()) {
                ChildrenNodes.Add(node);
            }
        }
Пример #10
0
        private string GetDirectiveText()
        {
            IT4Directive directive = GetTreeNode();
            string       name      = directive?.Name?.GetText();

            if (name == null)
            {
                return("???");
            }

            DirectiveInfo directiveInfo = T4DirectiveInfoManager.GetDirectiveByName(name);

            if (directiveInfo == null)
            {
                return(name);
            }

            // display the directive with the attributes that are marked with DisplayInCodeStructure
            var builder = new StringBuilder(name);

            foreach (IT4DirectiveAttribute attribute in directive.AttributesEnumerable)
            {
                DirectiveAttributeInfo attributeInfo = directiveInfo.GetAttributeByName(attribute.Name.GetText());
                if (attributeInfo?.IsDisplayedInCodeStructure != true)
                {
                    continue;
                }

                builder.Append(' ');
                builder.Append(attributeInfo.Name);
                if (attribute.Value != null)
                {
                    builder.Append("=\"");
                    builder.Append(attribute.Value.GetText());
                    builder.Append('"');
                }
            }
            return(builder.ToString());
        }
Пример #11
0
        protected override bool AddLookupItems(T4CodeCompletionContext context, IItemsCollector collector)
        {
            ITreeNode node = context.BasicContext.File.FindNodeAt(context.BasicContext.SelectedTreeRange);

            Assertion.AssertNotNull(node, "node == null");
            var ranges = context.BasicContext.GetRanges(node);

            collector.AddRanges(ranges);

            var directive = node.GetContainingNode <IT4Directive>();

            Assertion.AssertNotNull(directive, "directive != null");
            DirectiveInfo directiveInfo = _directiveInfoManager.GetDirectiveByName(directive.GetName());

            if (directiveInfo == null)
            {
                return(false);
            }

            JetHashSet <string> existingNames = directive
                                                .GetAttributes()
                                                .Select(attr => attr.GetName())
                                                .ToJetHashSet(s => s, StringComparer.OrdinalIgnoreCase);

            foreach (string attributeName in directiveInfo.SupportedAttributes.Select(attr => attr.Name))
            {
                if (existingNames.Contains(attributeName))
                {
                    continue;
                }

                var item = new TextLookupItem(attributeName);
                item.InitializeRanges(ranges, context.BasicContext);
                collector.Add(item);
            }

            return(true);
        }
Пример #12
0
        public ForNode(DirectiveInfo info)
            : base(info)
        {
            var node = ExpressionRewriter.Rewrite(Token.ReadTokens(info.ParametersReader));

            if(!node.Token.IsSymbol(",")) {
                throw new DataTypeException("Expected comma-separated list", this);
            }

            var children = node.GetChildrenTokens();

            if(children.Count < 3 || children.Count > 4) {
                throw new MissingDataException("#for directive requires 3 to 4 parameters", Location);
            }

            if(children[0].Token.TokenType != TokenType.Identifier) {
                throw new MissingDataException("Identifier", children[0].Location);
            }

            Variable = children[0].Token.ToString();
            Start = children[1];
            End = children[2];
            Step = children.Count > 3 ? children[3] : null;
        }
Пример #13
0
        /// <summary>Finds an anchor for a newly created directive inside a list of existing directives.</summary>
        /// <param name="newDirective">The directive to add.</param>
        /// <param name="existingDirectives">The existing directives.</param>
        /// <param name="directiveInfoManager">An instance of <see cref="DirectiveInfoManager"/>.</param>
        /// <returns>A pair indicating the anchor (can be null) and its relative position.</returns>
        public static Pair <IT4Directive, BeforeOrAfter> FindAnchor(
            [NotNull] this IT4Directive newDirective,
            [NotNull] IT4Directive[] existingDirectives,
            [NotNull] DirectiveInfoManager directiveInfoManager
            )
        {
            // no anchor
            if (existingDirectives.Length == 0)
            {
                return(Pair.Of((IT4Directive)null, BeforeOrAfter.Before));
            }

            // directive name should never be null, but you never know
            string newName = newDirective.GetName();

            if (String.IsNullOrEmpty(newName))
            {
                return(Pair.Of(existingDirectives.Last(), BeforeOrAfter.After));
            }

            var           lastDirectiveByName = new Dictionary <string, IT4Directive>(StringComparer.OrdinalIgnoreCase);
            DirectiveInfo directiveInfo       = directiveInfoManager.GetDirectiveByName(newName);
            string        newsortValue        = GetSortValue(newDirective, directiveInfo, directiveInfoManager);

            foreach (IT4Directive existingDirective in existingDirectives)
            {
                string existingName = existingDirective.GetName();
                if (existingName == null)
                {
                    continue;
                }

                lastDirectiveByName[existingName] = existingDirective;

                // directive of the same type as the new one:
                // if the new directive comes alphabetically before the existing one, we got out anchor
                if (String.Equals(existingName, newName, StringComparison.OrdinalIgnoreCase))
                {
                    string existingSortValue = GetSortValue(existingDirective, directiveInfo, directiveInfoManager);
                    if (String.Compare(newsortValue, existingSortValue, StringComparison.OrdinalIgnoreCase) < 0)
                    {
                        return(Pair.Of(existingDirective, BeforeOrAfter.Before));
                    }
                }
            }

            // no anchor being alphabetically after the new directive was found:
            // the last directive of the same type will be used as an anchor
            if (lastDirectiveByName.TryGetValue(newName, out IT4Directive lastDirective))
            {
                return(Pair.Of(lastDirective, BeforeOrAfter.After));
            }

            // there was no directive of the same type as the new one
            // the anchor will be the last directive of the type just before (determined by the position in DirectiveInfo.AllDirectives)
            if (directiveInfo != null)
            {
                int index = directiveInfoManager.AllDirectives.IndexOf(directiveInfo) - 1;
                while (index >= 0)
                {
                    if (lastDirectiveByName.TryGetValue(directiveInfoManager.AllDirectives[index].Name, out lastDirective))
                    {
                        return(Pair.Of(lastDirective, BeforeOrAfter.After));
                    }
                    --index;
                }
                return(Pair.Of(existingDirectives.First(), BeforeOrAfter.Before));
            }

            // we don't know the directive name (shouldn't happen), use the last directive as an anchor
            return(Pair.Of(existingDirectives.Last(), BeforeOrAfter.After));
        }
Пример #14
0
 public static IEnumerable <IT4Directive> GetDirectives([NotNull] this IT4DirectiveOwner directiveOwner, [NotNull] DirectiveInfo directiveInfo)
 => directiveOwner.GetDirectives().Where(d => directiveInfo.Name.Equals(d.GetName(), StringComparison.OrdinalIgnoreCase));
Пример #15
0
 public static bool IsSpecificDirective([CanBeNull] this IT4Directive directive, [CanBeNull] DirectiveInfo directiveInfo)
 => directive != null &&
 directiveInfo != null &&
 directiveInfo.Name.Equals(directive.GetName(), StringComparison.OrdinalIgnoreCase);
Пример #16
0
 /// <summary>
 /// Initializes a new instance of the <see cref="DirectiveNode"/> class.
 /// </summary>
 /// <param name="info">The directive's information.</param>
 protected DirectiveNode(DirectiveInfo info)
     : base(info.Location)
 {
     DirectiveName = info.DirectiveName;
 }
Пример #17
0
 /// <summary>
 /// Creates an instance of a directive.
 /// </summary>
 /// <param name="nodeType">Type of the directive node.</param>
 /// <param name="info">The new instance's directive information.</param>
 /// <returns>The new <see cref="DirectiveNode"/> instance.</returns>
 private static DirectiveNode CreateInstance(Type nodeType, DirectiveInfo info)
 {
     return Activator.CreateInstance(nodeType, info) as DirectiveNode;
 }
Пример #18
0
 public IfNode(DirectiveInfo info)
     : base(info)
 {
     Condition = ExpressionRewriter.Rewrite(Token.ReadTokens(info.ParametersReader));
 }
Пример #19
0
 public EndDirectiveNode(DirectiveInfo info)
     : base(info)
 {
 }
Пример #20
0
        public static IEnumerable <IT4Directive> GetDirectives([NotNull] this IT4DirectiveOwner directiveOwner, [NotNull] DirectiveInfo directiveInfo)
        {
            if (directiveOwner == null)
            {
                throw new ArgumentNullException("directiveOwner");
            }
            if (directiveInfo == null)
            {
                throw new ArgumentNullException("directiveInfo");
            }

            return(directiveOwner.GetDirectives().Where(d => directiveInfo.Name.Equals(d.GetName(), StringComparison.OrdinalIgnoreCase)));
        }
Пример #21
0
 public static IEnumerable <IT4Directive> GetDirectives(
     [NotNull] this IT4File file,
     [NotNull] DirectiveInfo directiveInfo
     ) => file.Blocks.OfType <IT4Directive>().Where(d =>
                                                    directiveInfo.Name.Equals(d.Name?.GetText(), StringComparison.OrdinalIgnoreCase));