private void ThrowIfNotTypeNameRelevant(BindingParserNode node)
{
if (ResolveOnlyTypeName && !(node is MemberAccessBindingParserNode) && !(node is IdentifierNameBindingParserNode))
{
throw new Exception("Only type name is supported.");
}
}
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();
}
}
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));
}
public override Expression Visit(BindingParserNode node)
{
var regBackup = Registry;
var errors = currentErrors;
try
{
return(base.Visit(node));
}
finally
{
currentErrors = errors;
Registry = regBackup;
}
}
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 IAbstractBaseTypeDirective BuildBaseTypeDirective(DothtmlDirectiveNode directive, BindingParserNode nameSyntax)
{
var type = ResolveTypeNameDirective(directive, nameSyntax);
return(new ResolvedBaseTypeDirective(nameSyntax, type)
{
DothtmlNode = directive
});
}
public BindingCompilationException(string message, BindingParserNode node)
: this(message, null, node)
{
}
public BindingCompilationException(string message, Exception innerException, BindingParserNode node)
: this(message, innerException, node.Tokens)
{
}
public ResolvedServiceInjectDirective(SimpleNameBindingParserNode nameSyntax, BindingParserNode typeSyntax, Type injectedType)
{
NameSyntax = nameSyntax;
TypeSyntax = typeSyntax;
Type = injectedType;
}
protected override string DefaultVisit(BindingParserNode node)
{
return("Yes");
}
public ResolvedTypeSpecificationDirective(BindingParserNode nameSyntax, ResolvedTypeDescriptor resolvedType)
{
this.NameSyntax = nameSyntax;
this.ResolvedType = resolvedType;
}
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));
}
}
public ResolvedImportDirective(BindingParserNode aliasSyntax, BindingParserNode nameSyntax, Type type)
{
AliasSyntax = aliasSyntax;
NameSyntax = nameSyntax;
Type = type;
}
public ResolvedBaseTypeDirective(BindingParserNode nameSyntax, ResolvedTypeDescriptor resolvedType)
: base(nameSyntax, resolvedType)
{
}
