protected override void Populate()
{
var constantPattern = Syntax.Pattern as ConstantPatternSyntax;
if (constantPattern != null)
{
Create(cx, Syntax.Expression, this, 0);
Create(cx, constantPattern.Expression, this, 3);
return;
}
var pattern = Syntax.Pattern as DeclarationPatternSyntax;
if (pattern == null)
{
throw new InternalError(Syntax, "Is-pattern not handled");
}
Create(cx, Syntax.Expression, this, 0);
TypeAccess.Create(cx, pattern.Type, this, 1);
var symbol = cx.Model(Syntax).GetDeclaredSymbol(pattern.Designation) as ILocalSymbol;
if (symbol != null)
{
var type = Type.Create(cx, symbol.Type);
var isVar = pattern.Type.IsVar;
VariableDeclaration.Create(cx, symbol, type, cx.Create(pattern.GetLocation()), cx.Create(pattern.Designation.GetLocation()), isVar, this, 2);
}
}
public static Expression Create(ExpressionNodeInfo info)
{
var symbolInfo = info.Context.GetSymbolInfo(info.Node);
var target = symbolInfo.Symbol;
if (target == null && symbolInfo.CandidateReason == CandidateReason.OverloadResolutionFailure)
{
// The expression is probably a cast
target = info.Context.GetSymbolInfo((CSharpSyntaxNode)info.Node.Parent).Symbol;
}
if (target == null && (symbolInfo.CandidateReason == CandidateReason.Ambiguous || symbolInfo.CandidateReason == CandidateReason.MemberGroup))
{
// Pick one at random - they probably resolve to the same ID
target = symbolInfo.CandidateSymbols.First();
}
if (target == null)
{
info.Context.ModelError(info.Node, "Failed to resolve name");
return(new Unknown(info));
}
// There is a very strange bug in Microsoft.CodeAnalysis whereby
// target.Kind throws System.InvalidOperationException for Discard symbols.
// So, short-circuit that test here.
// Ideally this would be another case in the switch statement below.
if (target is IDiscardSymbol)
{
return(new Discard(info));
}
switch (target.Kind)
{
case SymbolKind.TypeParameter:
case SymbolKind.NamedType:
case SymbolKind.DynamicType:
return(TypeAccess.Create(info));
case SymbolKind.Property:
case SymbolKind.Field:
case SymbolKind.Event:
case SymbolKind.Method:
return(Access.Create(info, target, true, info.Context.CreateEntity(target)));
case SymbolKind.Local:
case SymbolKind.RangeVariable:
return(Access.Create(info, target, false, LocalVariable.Create(info.Context, target)));
case SymbolKind.Parameter:
return(Access.Create(info, target, false, Parameter.Create(info.Context, (IParameterSymbol)target)));
case SymbolKind.Namespace:
return(Access.Create(info, target, false, Namespace.Create(info.Context, (INamespaceSymbol)target)));
default:
throw new InternalError(info.Node, $"Unhandled identifier kind '{target.Kind}'");
}
}
protected override void PopulateExpression(TextWriter trapFile)
{
Create(Context, Syntax.Expression, this, ExpressionIndex);
if (Kind == ExprKind.CAST)
{ // Type cast
TypeAccess.Create(new ExpressionNodeInfo(Context, Syntax.Type, this, TypeAccessIndex));
}
else
{
// Type conversion
OperatorCall(trapFile, Syntax);
TypeMention.Create(Context, Syntax.Type, this, Type);
}
}
protected override void Populate()
{
Create(cx, Syntax.Expression, this, 0);
if (Kind == ExprKind.CAST)
{
// Type cast
TypeAccess.Create(new ExpressionNodeInfo(cx, Syntax.Type, this, 1));
}
else
{
// Type conversion
OperatorCall(Syntax);
TypeMention.Create(cx, Syntax.Type, this, Type);
}
}
public static Expression CreateGenerated(Context cx, IExpressionParentEntity parent, int childIndex, Microsoft.CodeAnalysis.ITypeSymbol type, Extraction.Entities.Location location)
{
var info = new ExpressionInfo(
cx,
AnnotatedTypeSymbol.CreateNotAnnotated(type),
location,
ExprKind.TYPEOF,
parent,
childIndex,
true,
null);
var ret = new Expression(info);
TypeAccess.CreateGenerated(cx, ret, TypeOf.TypeAccessIndex, type, location);
return(ret);
}
public static Expression CreateGenerated(Context cx, IExpressionParentEntity parent, int childIndex, Microsoft.CodeAnalysis.ITypeSymbol type, object?value, Action <Expression, int> createChild, Extraction.Entities.Location location)
{
var info = new ExpressionInfo(
cx,
AnnotatedTypeSymbol.CreateNotAnnotated(type),
location,
ExprKind.CAST,
parent,
childIndex,
true,
ValueAsString(value));
var ret = new Expression(info);
createChild(ret, ExpressionIndex);
TypeAccess.CreateGenerated(cx, ret, TypeAccessIndex, type, location);
return(ret);
}
static Expression Create(ExpressionNodeInfo info, ExpressionSyntax expression, SimpleNameSyntax name)
{
if (IsDynamic(info.Context, expression))
{
var expr = new MemberAccess(info.SetKind(ExprKind.DYNAMIC_MEMBER_ACCESS), expression, null);
info.Context.Emit(Tuples.dynamic_member_name(expr, name.Identifier.Text));
return(expr);
}
var target = info.SymbolInfo;
if (target.CandidateReason == CandidateReason.OverloadResolutionFailure)
{
// Roslyn workaround. Even if we can't resolve a method, we know it's a method.
return(Create(info.Context, expression, info.Parent, info.Child));
}
var symbol = target.Symbol ?? info.Context.GetSymbolInfo(name).Symbol;
if (symbol == null && target.CandidateSymbols.Length >= 1)
{
// Pick the first symbol. This could occur for something like `nameof(Foo.Bar)`
// where `Bar` is a method group. Technically, we don't know which symbol is accessed.
symbol = target.CandidateSymbols[0];
}
if (symbol == null)
{
info.Context.ModelError(info.Node, "Failed to determine symbol for member access");
return(new MemberAccess(info.SetKind(ExprKind.UNKNOWN), expression, symbol));
}
ExprKind kind;
switch (symbol.Kind)
{
case SymbolKind.Property:
kind = ExprKind.PROPERTY_ACCESS;
break;
case SymbolKind.Method:
kind = ExprKind.METHOD_ACCESS;
break;
case SymbolKind.Field:
kind = ExprKind.FIELD_ACCESS;
break;
case SymbolKind.NamedType:
return(TypeAccess.Create(info));
case SymbolKind.Event:
kind = ExprKind.EVENT_ACCESS;
break;
default:
info.Context.ModelError(info.Node, "Unhandled symbol for member access");
kind = ExprKind.UNKNOWN;
break;
}
return(new MemberAccess(info.SetKind(kind), expression, symbol));
}
internal static Expression Create(ExpressionNodeInfo info)
{
// Some expressions can be extremely deep (e.g. string + string + string ...)
// to the extent that the stack has been known to overflow.
using (info.Context.StackGuard)
{
if (info.Node is null)
{
info.Context.ModelError(info.Location, "Attempt to create a null expression");
return(new Unknown(info));
}
switch (info.Node.Kind())
{
case SyntaxKind.AddExpression:
case SyntaxKind.SubtractExpression:
case SyntaxKind.LessThanExpression:
case SyntaxKind.LessThanOrEqualExpression:
case SyntaxKind.GreaterThanExpression:
case SyntaxKind.GreaterThanOrEqualExpression:
case SyntaxKind.MultiplyExpression:
case SyntaxKind.LogicalAndExpression:
case SyntaxKind.EqualsExpression:
case SyntaxKind.ModuloExpression:
case SyntaxKind.BitwiseAndExpression:
case SyntaxKind.BitwiseOrExpression:
case SyntaxKind.DivideExpression:
case SyntaxKind.NotEqualsExpression:
case SyntaxKind.LogicalOrExpression:
case SyntaxKind.IsExpression:
case SyntaxKind.AsExpression:
case SyntaxKind.RightShiftExpression:
case SyntaxKind.LeftShiftExpression:
case SyntaxKind.ExclusiveOrExpression:
case SyntaxKind.CoalesceExpression:
return(Binary.Create(info));
case SyntaxKind.FalseLiteralExpression:
case SyntaxKind.TrueLiteralExpression:
case SyntaxKind.StringLiteralExpression:
case SyntaxKind.NullLiteralExpression:
case SyntaxKind.NumericLiteralExpression:
case SyntaxKind.CharacterLiteralExpression:
case SyntaxKind.DefaultLiteralExpression:
return(Literal.Create(info));
case SyntaxKind.InvocationExpression:
return(Invocation.Create(info));
case SyntaxKind.PostIncrementExpression:
return(PostfixUnary.Create(info.SetKind(ExprKind.POST_INCR), ((PostfixUnaryExpressionSyntax)info.Node).Operand));
case SyntaxKind.PostDecrementExpression:
return(PostfixUnary.Create(info.SetKind(ExprKind.POST_DECR), ((PostfixUnaryExpressionSyntax)info.Node).Operand));
case SyntaxKind.AwaitExpression:
return(Await.Create(info));
case SyntaxKind.ElementAccessExpression:
return(NormalElementAccess.Create(info));
case SyntaxKind.SimpleAssignmentExpression:
case SyntaxKind.OrAssignmentExpression:
case SyntaxKind.AndAssignmentExpression:
case SyntaxKind.SubtractAssignmentExpression:
case SyntaxKind.AddAssignmentExpression:
case SyntaxKind.MultiplyAssignmentExpression:
case SyntaxKind.ExclusiveOrAssignmentExpression:
case SyntaxKind.LeftShiftAssignmentExpression:
case SyntaxKind.RightShiftAssignmentExpression:
case SyntaxKind.DivideAssignmentExpression:
case SyntaxKind.ModuloAssignmentExpression:
case SyntaxKind.CoalesceAssignmentExpression:
return(Assignment.Create(info));
case SyntaxKind.ObjectCreationExpression:
return(ExplicitObjectCreation.Create(info));
case SyntaxKind.ImplicitObjectCreationExpression:
return(ImplicitObjectCreation.Create(info));
case SyntaxKind.ArrayCreationExpression:
return(NormalArrayCreation.Create(info));
case SyntaxKind.ObjectInitializerExpression:
return(ObjectInitializer.Create(info));
case SyntaxKind.ArrayInitializerExpression:
return(ImplicitArrayInitializer.Create(info));
case SyntaxKind.CollectionInitializerExpression:
return(CollectionInitializer.Create(info));
case SyntaxKind.ConditionalAccessExpression:
return(MemberAccess.Create(info, (ConditionalAccessExpressionSyntax)info.Node));
case SyntaxKind.SimpleMemberAccessExpression:
return(MemberAccess.Create(info, (MemberAccessExpressionSyntax)info.Node));
case SyntaxKind.UnaryMinusExpression:
return(Unary.Create(info.SetKind(ExprKind.MINUS)));
case SyntaxKind.UnaryPlusExpression:
return(Unary.Create(info.SetKind(ExprKind.PLUS)));
case SyntaxKind.SimpleLambdaExpression:
return(Lambda.Create(info, (SimpleLambdaExpressionSyntax)info.Node));
case SyntaxKind.ParenthesizedLambdaExpression:
return(Lambda.Create(info, (ParenthesizedLambdaExpressionSyntax)info.Node));
case SyntaxKind.ConditionalExpression:
return(Conditional.Create(info));
case SyntaxKind.CastExpression:
return(Cast.Create(info));
case SyntaxKind.ParenthesizedExpression:
return(Create(info.SetNode(((ParenthesizedExpressionSyntax)info.Node).Expression)));
case SyntaxKind.PointerType:
case SyntaxKind.ArrayType:
case SyntaxKind.PredefinedType:
case SyntaxKind.NullableType:
case SyntaxKind.TupleType:
return(TypeAccess.Create(info));
case SyntaxKind.TypeOfExpression:
return(TypeOf.Create(info));
case SyntaxKind.QualifiedName:
case SyntaxKind.IdentifierName:
case SyntaxKind.AliasQualifiedName:
case SyntaxKind.GenericName:
return(Name.Create(info));
case SyntaxKind.LogicalNotExpression:
return(Unary.Create(info.SetKind(ExprKind.LOG_NOT)));
case SyntaxKind.BitwiseNotExpression:
return(Unary.Create(info.SetKind(ExprKind.BIT_NOT)));
case SyntaxKind.PreIncrementExpression:
return(Unary.Create(info.SetKind(ExprKind.PRE_INCR)));
case SyntaxKind.PreDecrementExpression:
return(Unary.Create(info.SetKind(ExprKind.PRE_DECR)));
case SyntaxKind.ThisExpression:
return(This.CreateExplicit(info));
case SyntaxKind.AddressOfExpression:
return(Unary.Create(info.SetKind(ExprKind.ADDRESS_OF)));
case SyntaxKind.PointerIndirectionExpression:
return(Unary.Create(info.SetKind(ExprKind.POINTER_INDIRECTION)));
case SyntaxKind.DefaultExpression:
return(Default.Create(info));
case SyntaxKind.CheckedExpression:
return(Checked.Create(info));
case SyntaxKind.UncheckedExpression:
return(Unchecked.Create(info));
case SyntaxKind.BaseExpression:
return(Base.Create(info));
case SyntaxKind.AnonymousMethodExpression:
return(Lambda.Create(info, (AnonymousMethodExpressionSyntax)info.Node));
case SyntaxKind.ImplicitArrayCreationExpression:
return(ImplicitArrayCreation.Create(info));
case SyntaxKind.AnonymousObjectCreationExpression:
return(AnonymousObjectCreation.Create(info));
case SyntaxKind.ComplexElementInitializerExpression:
return(CollectionInitializer.Create(info));
case SyntaxKind.SizeOfExpression:
return(SizeOf.Create(info));
case SyntaxKind.PointerMemberAccessExpression:
return(PointerMemberAccess.Create(info));
case SyntaxKind.QueryExpression:
return(Query.Create(info));
case SyntaxKind.InterpolatedStringExpression:
return(InterpolatedString.Create(info));
case SyntaxKind.MemberBindingExpression:
return(MemberAccess.Create(info, (MemberBindingExpressionSyntax)info.Node));
case SyntaxKind.ElementBindingExpression:
return(BindingElementAccess.Create(info));
case SyntaxKind.StackAllocArrayCreationExpression:
return(StackAllocArrayCreation.Create(info));
case SyntaxKind.ImplicitStackAllocArrayCreationExpression:
return(ImplicitStackAllocArrayCreation.Create(info));
case SyntaxKind.ArgListExpression:
return(ArgList.Create(info));
case SyntaxKind.RefTypeExpression:
return(RefType.Create(info));
case SyntaxKind.RefValueExpression:
return(RefValue.Create(info));
case SyntaxKind.MakeRefExpression:
return(MakeRef.Create(info));
case SyntaxKind.ThrowExpression:
return(Throw.Create(info));
case SyntaxKind.DeclarationExpression:
return(VariableDeclaration.Create(info.Context, (DeclarationExpressionSyntax)info.Node, info.Parent, info.Child));
case SyntaxKind.TupleExpression:
return(Tuple.Create(info));
case SyntaxKind.RefExpression:
return(Ref.Create(info));
case SyntaxKind.IsPatternExpression:
return(IsPattern.Create(info));
case SyntaxKind.RangeExpression:
return(RangeExpression.Create(info));
case SyntaxKind.IndexExpression:
return(Unary.Create(info.SetKind(ExprKind.INDEX)));
case SyntaxKind.SwitchExpression:
return(Switch.Create(info));
case SyntaxKind.SuppressNullableWarningExpression:
return(PostfixUnary.Create(info.SetKind(ExprKind.SUPPRESS_NULLABLE_WARNING), ((PostfixUnaryExpressionSyntax)info.Node).Operand));
case SyntaxKind.WithExpression:
return(WithExpression.Create(info));
default:
info.Context.ModelError(info.Node, $"Unhandled expression '{info.Node}' of kind '{info.Node.Kind()}'");
return(new Unknown(info));
}
}
}
protected override void PopulateExpression(TextWriter trapFile)
{
TypeAccess.Create(cx, Syntax.Type, this, 0);
}
protected override void Populate()
{
TypeAccess.Create(cx, Syntax.Type, this, 0);
}
protected override void PopulateExpression(TextWriter trapFile)
{
TypeAccess.Create(Context, Syntax.Type, this, TypeAccessIndex);
}