static bool IsInDeclarationContext(ParseItem current)
{
// exclude when not nested in rule block
if (current is ControlDirectiveBody && (current.Parent == null || !(current.Parent.Parent is RuleBlock)))
return false;
return current is RuleBlock || current is NestedPropertyBlock;
}
private bool IsNestedSelector(ParseItem current)
{
while (current != null)
{
if (current is RuleBlock)
return true;
current = current.Parent;
}
return false;
}
private SimpleSelector FindSelector(ParseItem item)
{
while (item != null)
{
if (item is SimpleSelector)
return item as SimpleSelector;
item = item.Parent;
}
return null;
}
public virtual void Add(ParseItem item, ITextProvider text)
{
if (item is VariableDefinition)
{
AddVariable(item as VariableDefinition, text);
}
else if (item is BlockItem)
{
var block = item as BlockItem;
Parse(new BlockScopeContainer(block), block.Children, text);
}
}
static PropertyDeclaration FindDeclaration(ParseItem item)
{
while (item != null)
{
if (item is PropertyDeclaration)
return item as PropertyDeclaration;
item = item.Parent;
}
return null;
}
static bool IsUnclosedVariable(ParseItem current)
{
while (current != null)
{
var definition = current as VariableDefinition;
if (definition != null && definition.Semicolon == null)
return true;
current = current.Parent;
}
return false;
}
public override bool Parse(IItemFactory itemFactory, ITextProvider text, ITokenStream stream)
{
ParseItem item;
if (itemFactory.TryCreateParsedOrDefault(this, text, stream, out item))
{
Value = item;
Children.Add(item);
}
if (stream.Current.Type == TokenType.Comma)
Comma = Children.AddCurrentAndAdvance(stream, SassClassifierType.Punctuation);
return Children.Count > 0;
}
public override void Add(ParseItem item, ITextProvider text)
{
if (item is SassImportDirective)
{
var directive = item as SassImportDirective;
foreach (var file in directive.Files.Where(x => x.IsValid))
Containers.Add(new ImportContainer(directive, IntellisenseManager.Get(file.Document)));
}
else if (item is XmlDocumentationComment)
{
var comment = item as XmlDocumentationComment;
foreach (var tag in comment.Children.OfType<FileReferenceTag>().Where(x => x.Document != null))
Containers.Add(new ImportContainer(tag, IntellisenseManager.Get(tag.Document)));
}
else if (item is MixinDefinition)
{
var definition = item as MixinDefinition;
if (definition.Name != null && definition.Name.Name != null)
{
Parse(new MixinContainer(definition, text), definition.Children, text);
var name = text.GetText(definition.Name.Name.Start, definition.Name.Name.Length);
_Mixins.Add(definition.End, new MixinCompletionValue(name));
}
}
else if (item is UserFunctionDefinition)
{
var definition = item as UserFunctionDefinition;
if (definition.Name != null)
{
Parse(new FunctionContainer(definition, text), definition.Children, text);
var name = text.GetText(definition.Name.Start, definition.Name.Length);
_Functions.Add(definition.End, new UserFunctionCompletionValue(name));
}
}
else
{
base.Add(item, text);
}
}
public void Add(ParseItem item, ITextProvider text)
{
throw new NotSupportedException("you can't add items to this type of container.");
}
public ImportContainer(ParseItem source, IIntellisenseCache cache)
{
Cache = cache;
Start = source.Start;
End = source.End;
}
private bool IsUnclosed(ParseItem current)
{
while (current != null)
{
if (current.IsUnclosed) return true;
if (current is BlockItem) return false;
current = current.Parent;
}
return false;
}
static bool IsDefinitionScope(ParseItem current)
{
return current is Stylesheet || current is BlockItem;
}
public bool TryCreate(ComplexItem parent, ITextProvider text, ITokenStream stream, out ParseItem item)
{
item = null;
switch (stream.Current.Type)
{
case TokenType.EndOfFile:
item = null;
return(false);
case TokenType.StartOfFile:
item = Create <Stylesheet>(parent, text, stream);
break;
case TokenType.NewLine:
item = new TokenItem();
break;
case TokenType.String:
case TokenType.BadString:
item = new StringValue();
break;
case TokenType.OpenCssComment:
item = new CssComment();
break;
case TokenType.CppComment:
item = new CppComment();
break;
case TokenType.OpenHtmlComment:
item = new HtmlComment();
break;
case TokenType.At:
item = CreateAtRule(parent, text, stream);
break;
case TokenType.Dollar:
item = CreateVariableDefinitionOrReference(parent, text, stream);
break;
case TokenType.Bang:
item = CreateBang(parent, text, stream);
break;
case TokenType.Function:
item = CreateFunction(parent, text, stream);
break;
case TokenType.XmlDocumentationComment:
item = new XmlDocumentationComment();
break;
case TokenType.Asterisk:
case TokenType.GreaterThan:
case TokenType.Tilde:
case TokenType.Colon:
case TokenType.DoubleColon:
case TokenType.Ampersand:
case TokenType.OpenBrace:
case TokenType.Hash:
case TokenType.Period:
case TokenType.Identifier:
case TokenType.OpenInterpolation:
item = CreateBestFittingItem(parent, text, stream);
break;
}
return(item != null);
}
public bool TryCreateParsed <T>(ComplexItem parent, ITextProvider text, ITokenStream stream, out ParseItem item) where T : ParseItem
{
item = null;
if (ExternalItemFactory != null)
{
item = ExternalItemFactory.CreateItem(this, text, stream, parent, typeof(T));
}
if (item == null && TryCreate(parent, text, stream, out item))
{
if (!(item is T))
{
item = null;
}
}
if (item != null)
{
return(item.Parse(this, text, stream));
}
return(false);
}
public bool TryCreateParsedOrDefault(ComplexItem parent, ITextProvider text, ITokenStream stream, out ParseItem item)
{
if (!TryCreate(parent, text, stream, out item))
{
item = new TokenItem();
}
if (!item.Parse(this, text, stream))
{
item = null;
}
return(item != null);
}
