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) { }