private Expression ParseDirectiveExpression(DothtmlDirectiveNode directive, BindingParserNode expressionSyntax)
{
TypeRegistry registry;
if (expressionSyntax is AssemblyQualifiedNameBindingParserNode)
{
var assemblyQualifiedName = expressionSyntax as AssemblyQualifiedNameBindingParserNode;
expressionSyntax = assemblyQualifiedName.TypeName;
registry = TypeRegistry.DirectivesDefault(compiledAssemblyCache, assemblyQualifiedName.AssemblyName.ToDisplayString());
}
else
{
registry = TypeRegistry.DirectivesDefault(compiledAssemblyCache);
}
var visitor = new ExpressionBuildingVisitor(registry)
{
ResolveOnlyTypeName = true,
Scope = null
};
try
{
return(visitor.Visit(expressionSyntax));
}
catch (Exception ex)
{
directive.AddError($"{expressionSyntax.ToDisplayString()} is not a valid type or namespace: {ex.Message}");
return(null);
}
}
protected virtual IAbstractDirective ProcessImportDirective(DothtmlDirectiveNode directiveNode)
{
var tokenizer = new BindingTokenizer();
tokenizer.Tokenize(directiveNode.ValueNode.Text);
var parser = new BindingParser()
{
Tokens = tokenizer.Tokens
};
var valueSyntaxRoot = parser.ReadDirectiveValue();
if (!parser.OnEnd())
{
directiveNode.AddError($"Unexpected token: {parser.Peek()?.Text}.");
}
BindingParserNode alias = null;
BindingParserNode name = null;
if (valueSyntaxRoot is BinaryOperatorBindingParserNode)
{
var assigment = valueSyntaxRoot.CastTo <BinaryOperatorBindingParserNode>();
alias = assigment.FirstExpression;
name = assigment.SecondExpression;
}
else
{
name = valueSyntaxRoot;
}
return(treeBuilder.BuildImportDirective(directiveNode, alias, name));
}
public IAbstractServiceInjectDirective BuildServiceInjectDirective(
DothtmlDirectiveNode node,
SimpleNameBindingParserNode nameSyntax,
BindingParserNode typeSyntax)
{
foreach (var syntaxNode in nameSyntax.EnumerateNodes().Concat(typeSyntax?.EnumerateNodes() ?? Enumerable.Empty <BindingParserNode>()))
{
syntaxNode.NodeErrors.ForEach(node.AddError);
}
var expression = ParseDirectiveExpression(node, typeSyntax);
if (expression is UnknownStaticClassIdentifierExpression)
{
node.AddError($"{typeSyntax.ToDisplayString()} is not a valid type.");
return(new ResolvedServiceInjectDirective(nameSyntax, typeSyntax, null)
{
DothtmlNode = node
});
}
else if (expression is StaticClassIdentifierExpression)
{
return(new ResolvedServiceInjectDirective(nameSyntax, typeSyntax, expression.Type)
{
DothtmlNode = node
});
}
else
{
throw new NotSupportedException();
}
}
protected virtual IAbstractDirective ProcessServiceInjectDirective(DothtmlDirectiveNode directiveNode)
{
var valueSyntaxRoot = ParseImportDirectiveValue(directiveNode);
if (valueSyntaxRoot is BinaryOperatorBindingParserNode assigment)
{
var name = assigment.FirstExpression as SimpleNameBindingParserNode;
if (name == null)
{
directiveNode.AddError($"Identifier expected on the left side of the assigment.");
name = new SimpleNameBindingParserNode(new BindingToken {
Text = "service"
});
}
var type = assigment.SecondExpression;
return(treeBuilder.BuildServiceInjectDirective(directiveNode, name, type));
}
else
{
directiveNode.AddError($"Assignment operation expected - the correct form is `@{ParserConstants.ServiceInjectDirective} myStringService = ISomeService<string>`");
return(treeBuilder.BuildServiceInjectDirective(directiveNode, new SimpleNameBindingParserNode(new BindingToken {
Text = "service"
}), valueSyntaxRoot));
}
}
public IAbstractDirective BuildDirective(DothtmlDirectiveNode node)
{
return(new ResolvedDirective()
{
DothtmlNode = node
});
}
public IAbstractImportDirective BuildImportDirective(
DothtmlDirectiveNode node,
BindingParserNode aliasSyntax,
BindingParserNode nameSyntax)
{
foreach (var syntaxNode in nameSyntax.EnumerateNodes().Concat(aliasSyntax?.EnumerateNodes() ?? Enumerable.Empty <BindingParserNode>()))
{
syntaxNode.NodeErrors.ForEach(node.AddError);
}
var visitor = new ExpressionBuildingVisitor(TypeRegistry.DirectivesDefault)
{
ResolveOnlyTypeName = true,
Scope = null
};
Expression expression;
try
{
expression = visitor.Visit(nameSyntax);
}
catch (Exception ex)
{
node.AddError($"{nameSyntax.ToDisplayString()} is not a valid type or namespace: {ex.Message}");
return(new ResolvedImportDirective(aliasSyntax, nameSyntax, null)
{
DothtmlNode = node
});
}
if (expression is UnknownStaticClassIdentifierExpression)
{
var namespaceValid = expression
.CastTo <UnknownStaticClassIdentifierExpression>().Name
.Apply(ReflectionUtils.IsAssemblyNamespace);
if (!namespaceValid)
{
node.AddError($"{nameSyntax.ToDisplayString()} is unknown type or namespace.");
}
return(new ResolvedImportDirective(aliasSyntax, nameSyntax, null)
{
DothtmlNode = node
});
}
else if (expression is StaticClassIdentifierExpression)
{
return(new ResolvedImportDirective(aliasSyntax, nameSyntax, expression.Type)
{
DothtmlNode = node
});
}
node.AddError($"{nameSyntax.ToDisplayString()} is not a type or namespace.");
return(new ResolvedImportDirective(aliasSyntax, nameSyntax, null));
}
protected virtual IAbstractDirective ProcessDirective(DothtmlDirectiveNode directiveNode)
{
if (string.Equals(ParserConstants.ImportNamespaceDirective, directiveNode.Name) || string.Equals(ParserConstants.ResourceNamespaceDirective, directiveNode.Name))
{
return(ProcessImportDirective(directiveNode));
}
return(treeBuilder.BuildDirective(directiveNode));
}
public IAbstractBaseTypeDirective BuildBaseTypeDirective(DothtmlDirectiveNode directive, BindingParserNode nameSyntax)
{
var type = ResolveTypeNameDirective(directive, nameSyntax);
return(new ResolvedBaseTypeDirective(nameSyntax, type)
{
DothtmlNode = directive
});
}
private ResolvedTypeDescriptor ResolveTypeNameDirective(DothtmlDirectiveNode directive, BindingParserNode nameSyntax)
{
var expression = ParseDirectiveExpression(directive, nameSyntax) as StaticClassIdentifierExpression;
if (expression == null)
{
directive.AddError($"Could not resolve type '{nameSyntax.ToDisplayString()}'.");
return(null);
}
else
{
return(new ResolvedTypeDescriptor(expression.Type));
}
}
protected virtual BindingParserNode ParseDirectiveTypeName(DothtmlDirectiveNode directiveNode)
{
var tokenizer = new BindingTokenizer();
tokenizer.Tokenize(directiveNode.ValueNode.Text);
var parser = new BindingParser()
{
Tokens = tokenizer.Tokens
};
var valueSyntaxRoot = parser.ReadDirectiveTypeName();
if (!parser.OnEnd())
{
directiveNode.AddError($"Unexpected token: {parser.Peek()?.Text}.");
}
return(valueSyntaxRoot);
}
protected virtual IAbstractDirective ProcessDirective(DothtmlDirectiveNode directiveNode)
{
if (string.Equals(ParserConstants.ImportNamespaceDirective, directiveNode.Name) || string.Equals(ParserConstants.ResourceNamespaceDirective, directiveNode.Name))
{
return(ProcessImportDirective(directiveNode));
}
else if (string.Equals(ParserConstants.ViewModelDirectiveName, directiveNode.Name, StringComparison.OrdinalIgnoreCase))
{
return(ProcessViewModelDirective(directiveNode));
}
else if (string.Equals(ParserConstants.BaseTypeDirective, directiveNode.Name, StringComparison.OrdinalIgnoreCase))
{
return(ProcessBaseTypeDirective(directiveNode));
}
return(treeBuilder.BuildDirective(directiveNode));
}
private bool NavigateToMasterPage(DothtmlDirectiveNode masterPageDirective)
{
//get full path of item
var path = DTEHelper.GetCurrentProject().Properties.Item("FullPath").Value;
var itemFullPath = Path.Combine(path, masterPageDirective.Value);
//check if item exists
if (File.Exists(itemFullPath))
{
//navigate to item
var item = DTEHelper.GetProjectItemByFullPath(itemFullPath);
DTEHelper.ChangeActiveWindowTo(item);
return(true);
}
return(false);
}
protected BindingParserNode ParseImportDirectiveValue(DothtmlDirectiveNode directiveNode)
{
var tokenizer = new BindingTokenizer();
tokenizer.Tokenize(directiveNode.ValueNode.Text);
var parser = new BindingParser()
{
Tokens = tokenizer.Tokens
};
var result = parser.ReadDirectiveValue();
if (!parser.OnEnd())
{
directiveNode.AddError($"Unexpected token: {parser.Peek()?.Text}.");
}
return(result);
}
protected virtual IAbstractDirective ProcessImportDirective(DothtmlDirectiveNode directiveNode)
{
var valueSyntaxRoot = ParseImportDirectiveValue(directiveNode);
BindingParserNode alias = null;
BindingParserNode name = null;
if (valueSyntaxRoot is BinaryOperatorBindingParserNode assigment)
{
alias = assigment.FirstExpression;
name = assigment.SecondExpression;
}
else
{
name = valueSyntaxRoot;
}
return(treeBuilder.BuildImportDirective(directiveNode, alias, name));
}
public IAbstractImportDirective BuildImportDirective(
DothtmlDirectiveNode node,
BindingParserNode aliasSyntax,
BindingParserNode nameSyntax)
{
foreach (var syntaxNode in nameSyntax.EnumerateNodes().Concat(aliasSyntax?.EnumerateNodes() ?? Enumerable.Empty <BindingParserNode>()))
{
syntaxNode.NodeErrors.ForEach(node.AddError);
}
var expression = ParseDirectiveExpression(node, nameSyntax);
if (expression is UnknownStaticClassIdentifierExpression)
{
var namespaceValid = expression
.CastTo <UnknownStaticClassIdentifierExpression>().Name
.Apply(compiledAssemblyCache.IsAssemblyNamespace);
if (!namespaceValid)
{
node.AddError($"{nameSyntax.ToDisplayString()} is unknown type or namespace.");
}
return(new ResolvedImportDirective(aliasSyntax, nameSyntax, null)
{
DothtmlNode = node
});
}
else if (expression is StaticClassIdentifierExpression)
{
return(new ResolvedImportDirective(aliasSyntax, nameSyntax, expression.Type)
{
DothtmlNode = node
});
}
node.AddError($"{nameSyntax.ToDisplayString()} is not a type or namespace.");
return(new ResolvedImportDirective(aliasSyntax, nameSyntax, null)
{
DothtmlNode = node
});
}
public ViewModelDirectiveValue(DothtmlDirectiveNode dothtmlDirectiveNode) : base(dothtmlDirectiveNode.Value ?? "")
{
DothtmlDirectiveNode = dothtmlDirectiveNode;
if (Value.Contains(separator))
{
var values = Value.Split(separator);
TypeFullName = values[0];
AssamblyName = values[1].Trim();
}
else
{
TypeFullName = Value;
}
TypeFullName = TypeFullName.Trim();
if (TypeFullName.Contains('.'))
{
var splited = TypeFullName.Split('.').ToList();
TypeName = splited.LastOrDefault()?.Trim();
splited.Remove(TypeName);
Namespace = string.Join(".", splited).Trim();
}
}
protected virtual IAbstractDirective ProcessBaseTypeDirective(DothtmlDirectiveNode directiveNode)
{
return(this.treeBuilder.BuildBaseTypeDirective(directiveNode, ParseDirectiveTypeName(directiveNode)));
}
public void Visit(DothtmlDirectiveNode directive)
{
ResolveFromParent(directive);
}
public void Visit(DothtmlDirectiveNode directive)
{
ResolveFromParent(directive);
}
/// <summary>
/// Reads the directive.
/// </summary>
private DothtmlDirectiveNode ReadDirective()
{
var startIndex = CurrentIndex;
var node = new DothtmlDirectiveNode() { StartPosition = Peek().StartPosition };
Assert(DothtmlTokenType.DirectiveStart);
Read();
SkipWhitespace();
Assert(DothtmlTokenType.DirectiveName);
var directiveNameToken = Read();
node.Name = directiveNameToken.Text.Trim();
SkipWhitespace();
Assert(DothtmlTokenType.DirectiveValue);
var directiveValueToken = Read();
node.Value = directiveValueToken.Text.Trim();
SkipWhitespace();
node.Tokens.AddRange(GetTokensFrom(startIndex));
return node;
}
