public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
{
if (syntax.Value is ForSyntax)
{
this.Visit(syntax.Value);
}
}
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
{
currentDeclaration = declarations[syntax.Name.IdentifierName];
declarationAccessDict[currentDeclaration] = new List <SyntaxBase>();
base.VisitOutputDeclarationSyntax(syntax);
currentDeclaration = null;
}
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
{
base.VisitOutputDeclarationSyntax(syntax);
var symbol = new OutputSymbol(this.context, syntax.Name.IdentifierName, syntax, syntax.Value);
this.declaredSymbols.Add(symbol);
}
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax) =>
this.BuildStatement(syntax, () =>
{
this.VisitNodes(syntax.LeadingNodes);
this.Visit(syntax.Keyword);
this.documentStack.Push(Nil);
this.Visit(syntax.Name);
this.Visit(syntax.Type);
this.Visit(syntax.Assignment);
this.Visit(syntax.Value);
});
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
=> AssignTypeWithCaching(syntax, () => {
var primitiveType = LanguageConstants.TryGetDeclarationType(syntax.Type.TypeName);
if (primitiveType == null)
{
return(new ErrorTypeSymbol(DiagnosticBuilder.ForPosition(syntax.Type).InvalidOutputType()));
}
return(primitiveType);
});
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
{
allowedFlags = FunctionFlags.OutputDecorator;
this.VisitNodes(syntax.LeadingNodes);
this.Visit(syntax.Keyword);
this.Visit(syntax.Name);
this.Visit(syntax.Type);
this.Visit(syntax.Assignment);
allowedFlags = FunctionFlags.RequiresInlining;
this.Visit(syntax.Value);
allowedFlags = FunctionFlags.Default;
}
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
=> AssignTypeWithDiagnostics(syntax, diagnostics => {
var primitiveType = LanguageConstants.TryGetDeclarationType(syntax.Type.TypeName);
if (primitiveType == null)
{
return(new ErrorTypeSymbol(DiagnosticBuilder.ForPosition(syntax.Type).InvalidOutputType()));
}
var currentDiagnostics = GetOutputDeclarationDiagnostics(primitiveType, syntax);
diagnostics.AddRange(currentDiagnostics);
return(primitiveType);
});
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
{
// Does the output name contain 'password' (suggesting it contains an actual password)?
if (syntax.Name.IdentifierName.Contains("password", StringComparison.OrdinalIgnoreCase))
{
string foundMessage = string.Format(CoreResources.OutputsShouldNotContainSecretsOutputName, syntax.Name.IdentifierName);
this.diagnostics.Add(parent.CreateDiagnosticForSpan(syntax.Span, foundMessage));
}
var visitor = new OutputValueVisitor(this.parent, diagnostics, model);
visitor.Visit(syntax);
// Note: No need to navigate deeper, don't call base
}
private IEnumerable <Diagnostic> GetOutputDeclarationDiagnostics(OutputDeclarationSyntax syntax)
{
var assignedType = typeManager.GetTypeInfo(syntax);
var valueType = typeManager.GetTypeInfo(syntax.Value);
// this type is not a property in a symbol so the semantic error visitor won't collect the errors automatically
if (valueType is ErrorTypeSymbol)
{
return(valueType.GetDiagnostics());
}
if (TypeValidator.AreTypesAssignable(valueType, assignedType) == false)
{
return(DiagnosticBuilder.ForPosition(syntax.Value).OutputTypeMismatch(assignedType.Name, valueType.Name).AsEnumerable());
}
return(Enumerable.Empty <Diagnostic>());
}
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
=> AssignTypeWithDiagnostics(syntax, diagnostics =>
{
// assume "any" type if the output type has parse errors (either missing or skipped)
var primitiveType = syntax.OutputType == null
? LanguageConstants.Any
: LanguageConstants.TryGetDeclarationType(syntax.OutputType.TypeName);
if (primitiveType == null)
{
return(new ErrorTypeSymbol(DiagnosticBuilder.ForPosition(syntax.Type).InvalidOutputType()));
}
var currentDiagnostics = GetOutputDeclarationDiagnostics(primitiveType, syntax);
diagnostics.AddRange(currentDiagnostics);
return(primitiveType);
});
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
{
allowedFlags = FunctionFlags.RequiresInlining;
base.VisitOutputDeclarationSyntax(syntax);
allowedFlags = FunctionFlags.Default;
}
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax) => this.BuildStatement(syntax, () => base.VisitOutputDeclarationSyntax(syntax));
public OutputSymbol(ISymbolContext context, string name, OutputDeclarationSyntax declaringSyntax, SyntaxBase value)
: base(context, name, declaringSyntax, declaringSyntax.Name)
{
this.Value = value;
}
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax) => this.BuildWithSpread(() => base.VisitOutputDeclarationSyntax(syntax));
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
{
var currentDiagnostics = GetOutputDeclarationDiagnostics(syntax);
diagnostics.AddRange(currentDiagnostics);
}
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax) => VisitDeclaration(syntax, base.VisitOutputDeclarationSyntax);
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
{
this.activeLoopCapableTopLevelDeclaration = syntax;
base.VisitOutputDeclarationSyntax(syntax);
this.activeLoopCapableTopLevelDeclaration = null;
}
public override void VisitOutputDeclarationSyntax(OutputDeclarationSyntax syntax)
{
AddCodeFixIfSingleInterpolatedString(syntax.Value);
base.VisitOutputDeclarationSyntax(syntax);
}
