public override void Populate(TextWriter trapFile)
{
PopulateMethod(trapFile);
PopulateModifiers(trapFile);
ContainingType.PopulateGenerics();
var returnType = Type.Create(Context, symbol.ReturnType);
trapFile.methods(this, Name, ContainingType, returnType.TypeRef, OriginalDefinition);
if (IsSourceDeclaration)
{
foreach (var declaration in symbol.DeclaringSyntaxReferences.Select(s => s.GetSyntax()).OfType <MethodDeclarationSyntax>())
{
Context.BindComments(this, declaration.Identifier.GetLocation());
TypeMention.Create(Context, declaration.ReturnType, this, returnType);
}
}
foreach (var l in Locations)
{
trapFile.method_location(this, l);
}
PopulateGenerics(trapFile);
Overrides(trapFile);
ExtractRefReturn(trapFile, symbol, this);
ExtractCompilerGenerated(trapFile);
}
public static TypeMention Create(Context cx, TypeSyntax syntax, IEntity parent, Type type, Microsoft.CodeAnalysis.Location?loc = null)
{
var ret = new TypeMention(cx, syntax, parent, type, loc);
cx.Try(syntax, null, () => ret.Populate(cx.TrapWriter.Writer));
return(ret);
}
public override void Populate(TextWriter trapFile)
{
PopulateMethod(trapFile);
PopulateModifiers(trapFile);
var returnType = Type.Create(Context, Symbol.ReturnType);
trapFile.operators(this,
Symbol.Name,
OperatorSymbol(Context, Symbol),
ContainingType,
returnType.TypeRef,
(UserOperator)OriginalDefinition);
foreach (var l in Locations)
{
trapFile.operator_location(this, l);
}
if (IsSourceDeclaration)
{
var declSyntaxReferences = Symbol.DeclaringSyntaxReferences.Select(s => s.GetSyntax()).ToArray();
foreach (var declaration in declSyntaxReferences.OfType <OperatorDeclarationSyntax>())
{
TypeMention.Create(Context, declaration.ReturnType, this, returnType);
}
foreach (var declaration in declSyntaxReferences.OfType <ConversionOperatorDeclarationSyntax>())
{
TypeMention.Create(Context, declaration.Type, this, returnType);
}
}
ContainingType.PopulateGenerics();
}
public override void Populate()
{
PopulateMethod();
ExtractModifiers();
var returnType = Type.Create(Context, symbol.ReturnType);
Context.Emit(Tuples.operators(this,
symbol.Name,
OperatorSymbol(Context, symbol.Name),
ContainingType,
returnType.TypeRef,
(UserOperator)OriginalDefinition));
foreach (var l in Locations)
{
Context.Emit(Tuples.operator_location(this, l));
}
if (IsSourceDeclaration)
{
var declSyntaxReferences = symbol.DeclaringSyntaxReferences.Select(s => s.GetSyntax()).ToArray();
foreach (var declaration in declSyntaxReferences.OfType <OperatorDeclarationSyntax>())
{
TypeMention.Create(Context, declaration.ReturnType, this, returnType);
}
foreach (var declaration in declSyntaxReferences.OfType <ConversionOperatorDeclarationSyntax>())
{
TypeMention.Create(Context, declaration.Type, this, returnType);
}
}
ContainingType.ExtractGenerics();
}
void ExtractAttribute(System.IO.TextWriter trapFile, AttributeSyntax syntax, ITypeSymbol attributeClass, IEntity entity)
{
var type = Type.Create(cx, attributeClass);
trapFile.attributes(this, type.TypeRef, entity);
trapFile.attribute_location(this, cx.Create(syntax.Name.GetLocation()));
if (cx.Extractor.OutputPath != null)
{
trapFile.attribute_location(this, Assembly.CreateOutputAssembly(cx));
}
TypeMention.Create(cx, syntax.Name, this, type);
if (syntax.ArgumentList != null)
{
cx.PopulateLater(() =>
{
int child = 0;
foreach (var arg in syntax.ArgumentList.Arguments)
{
var expr = Expression.Create(cx, arg.Expression, this, child++);
if (!(arg.NameEquals is null))
{
trapFile.expr_argument_name(expr, arg.NameEquals.Name.Identifier.Text);
}
}
});
}
}
void ExtractAttribute(AttributeSyntax syntax, ITypeSymbol attributeClass, IEntity entity)
{
var type = Type.Create(cx, attributeClass);
cx.Emit(Tuples.attributes(this, type.TypeRef, entity));
cx.Emit(Tuples.attribute_location(this, cx.Create(syntax.Name.GetLocation())));
if (cx.Extractor.OutputPath != null)
{
cx.Emit(Tuples.attribute_location(this, Assembly.CreateOutputAssembly(cx)));
}
TypeMention.Create(cx, syntax.Name, this, type);
if (syntax.ArgumentList != null)
{
cx.PopulateLater(() =>
{
int child = 0;
foreach (var arg in syntax.ArgumentList.Arguments)
{
Expression.Create(cx, arg.Expression, this, child++);
}
// !! Handle named arguments
});
}
}
public override void Populate(TextWriter trapFile)
{
PopulateAttributes();
PopulateNullability(trapFile, Symbol.GetAnnotatedType());
PopulateRefKind(trapFile, Symbol.RefKind);
if (Symbol.Name != Original.Symbol.Name)
{
Context.ModelError(Symbol, "Inconsistent parameter declaration");
}
var type = Type.Create(Context, Symbol.Type);
trapFile.@params(this, Name, type.TypeRef, Ordinal, ParamKind, Parent !, Original);
foreach (var l in Symbol.Locations)
{
trapFile.param_location(this, Context.CreateLocation(l));
}
if (!Symbol.Locations.Any() &&
Symbol.ContainingSymbol is IMethodSymbol ms &&
ms.Name == WellKnownMemberNames.TopLevelStatementsEntryPointMethodName &&
ms.ContainingType.Name == WellKnownMemberNames.TopLevelStatementsEntryPointTypeName)
{
trapFile.param_location(this, Context.CreateLocation());
}
if (Symbol.HasExplicitDefaultValue && Context.Defines(Symbol))
{
var defaultValueSyntax = GetDefaultValueFromSyntax(Symbol);
Action defaultValueExpressionCreation = defaultValueSyntax is not null
? () => Expression.Create(Context, defaultValueSyntax.Value, this, 0)
: () => Expression.CreateGenerated(Context, Symbol, this, 0, Location);
Context.PopulateLater(defaultValueExpressionCreation);
}
if (!IsSourceDeclaration || !Symbol.FromSource())
{
return;
}
BindComments();
if (IsSourceDeclaration)
{
foreach (var syntax in Symbol.DeclaringSyntaxReferences
.Select(d => d.GetSyntax())
.OfType <ParameterSyntax>()
.Where(s => s.Type is not null))
{
TypeMention.Create(Context, syntax.Type !, this, type);
}
}
}
public override void Populate(TextWriter trapFile)
{
PopulateNullability(trapFile, Symbol.GetAnnotatedType());
var type = Type.Create(Context, Symbol.Type);
trapFile.events(this, Symbol.GetName(), ContainingType !, type.TypeRef, Create(Context, Symbol.OriginalDefinition));
var adder = Symbol.AddMethod;
var remover = Symbol.RemoveMethod;
if (!(adder is null))
{
Method.Create(Context, adder);
}
if (!(remover is null))
{
Method.Create(Context, remover);
}
PopulateModifiers(trapFile);
BindComments();
var declSyntaxReferences = IsSourceDeclaration
? Symbol.DeclaringSyntaxReferences.Select(d => d.GetSyntax()).ToArray()
: Enumerable.Empty <SyntaxNode>();
foreach (var explicitInterface in Symbol.ExplicitInterfaceImplementations.Select(impl => Type.Create(Context, impl.ContainingType)))
{
trapFile.explicitly_implements(this, explicitInterface.TypeRef);
foreach (var syntax in declSyntaxReferences.OfType <EventDeclarationSyntax>())
{
TypeMention.Create(Context, syntax.ExplicitInterfaceSpecifier !.Name, this, explicitInterface);
}
}
foreach (var l in Locations)
{
trapFile.event_location(this, l);
}
foreach (var syntaxType in declSyntaxReferences
.OfType <VariableDeclaratorSyntax>()
.Select(d => d.Parent)
.OfType <VariableDeclarationSyntax>()
.Select(syntax => syntax.Type))
{
TypeMention.Create(Context, syntaxType, this, type);
}
}
public override void Populate()
{
var type = Type.Create(Context, symbol.Type);
Context.Emit(Tuples.events(this, symbol.GetName(), ContainingType, type.TypeRef, Create(Context, symbol.OriginalDefinition)));
var adder = symbol.AddMethod;
if (adder != null)
{
EventAccessor.Create(Context, adder);
}
var remover = symbol.RemoveMethod;
if (remover != null)
{
EventAccessor.Create(Context, remover);
}
ExtractModifiers();
BindComments();
var declSyntaxReferences = IsSourceDeclaration
? symbol.DeclaringSyntaxReferences.Select(d => d.GetSyntax()).ToArray()
: Enumerable.Empty <SyntaxNode>();
foreach (var explicitInterface in symbol.ExplicitInterfaceImplementations.Select(impl => Type.Create(Context, impl.ContainingType)))
{
Context.Emit(Tuples.explicitly_implements(this, explicitInterface.TypeRef));
foreach (var syntax in declSyntaxReferences.OfType <EventDeclarationSyntax>())
{
TypeMention.Create(Context, syntax.ExplicitInterfaceSpecifier.Name, this, explicitInterface);
}
}
foreach (var l in Locations)
{
Context.Emit(Tuples.event_location(this, l));
}
foreach (var syntaxType in declSyntaxReferences.OfType <VariableDeclaratorSyntax>().
Select(d => d.Parent).
OfType <VariableDeclarationSyntax>().
Select(syntax => syntax.Type))
{
TypeMention.Create(Context, syntaxType, this, type);
}
}
public override void Populate(TextWriter trapFile)
{
var type = Type.Create(Context, symbol.AttributeClass);
trapFile.attributes(this, type.TypeRef, entity);
trapFile.attribute_location(this, Location);
if (attributeSyntax is object)
{
if (Context.Extractor.OutputPath != null)
{
trapFile.attribute_location(this, Assembly.CreateOutputAssembly(Context));
}
TypeMention.Create(Context, attributeSyntax.Name, this, type);
}
ExtractArguments(trapFile);
}
public override void Populate(TextWriter trapFile)
{
var type = Type.Create(Context, Symbol.AttributeClass);
trapFile.attributes(this, kind, type.TypeRef, entity);
trapFile.attribute_location(this, Location);
if (attributeSyntax is not null)
{
if (!Context.Extractor.Mode.HasFlag(ExtractorMode.Standalone))
{
trapFile.attribute_location(this, Assembly.CreateOutputAssembly(Context));
}
TypeMention.Create(Context, attributeSyntax.Name, this, type);
}
ExtractArguments(trapFile);
}
public override void Populate(TextWriter trapFile)
{
trapFile.types(this, Kinds.TypeKind.TYPE_PARAMETER, Symbol.Name);
TypeParameterConstraints.Create(Context, this);
var parentNs = Namespace.Create(Context, Symbol.TypeParameterKind == TypeParameterKind.Method ? Context.Compilation.GlobalNamespace : Symbol.ContainingNamespace);
trapFile.parent_namespace(this, parentNs);
foreach (var l in Symbol.Locations)
{
trapFile.type_location(this, Context.CreateLocation(l));
}
if (IsSourceDeclaration)
{
var declSyntaxReferences = Symbol.DeclaringSyntaxReferences
.Select(d => d.GetSyntax())
.Select(s => s.Parent)
.Where(p => p is not null)
.Select(p => p !.Parent)
.ToArray();
var clauses = declSyntaxReferences.OfType <MethodDeclarationSyntax>().SelectMany(m => m.ConstraintClauses);
clauses = clauses.Concat(declSyntaxReferences.OfType <ClassDeclarationSyntax>().SelectMany(c => c.ConstraintClauses));
clauses = clauses.Concat(declSyntaxReferences.OfType <InterfaceDeclarationSyntax>().SelectMany(c => c.ConstraintClauses));
clauses = clauses.Concat(declSyntaxReferences.OfType <StructDeclarationSyntax>().SelectMany(c => c.ConstraintClauses));
foreach (var clause in clauses.Where(c => c.Name.Identifier.Text == Symbol.Name))
{
TypeMention.Create(Context, clause.Name, this, this);
foreach (var constraint in clause.Constraints.OfType <TypeConstraintSyntax>())
{
var ti = Context.GetModel(constraint).GetTypeInfo(constraint.Type);
var target = Type.Create(Context, ti.Type);
TypeMention.Create(Context, constraint.Type, this, target);
}
}
}
}
public void Overrides()
{
foreach (var explicitInterface in symbol.ExplicitInterfaceImplementations.
Where(sym => sym.MethodKind == MethodKind.Ordinary).
Select(impl => Type.Create(Context, impl.ContainingType)))
{
Context.Emit(Tuples.explicitly_implements(this, explicitInterface.TypeRef));
if (IsSourceDeclaration)
{
foreach (var syntax in symbol.DeclaringSyntaxReferences.Select(d => d.GetSyntax()).OfType <MethodDeclarationSyntax>())
{
TypeMention.Create(Context, syntax.ExplicitInterfaceSpecifier.Name, this, explicitInterface);
}
}
}
if (symbol.OverriddenMethod != null)
{
Context.Emit(Tuples.overrides(this, Method.Create(Context, symbol.OverriddenMethod)));
}
}
public override void Populate(TextWriter trapFile)
{
var constraints = new TypeParameterConstraints(Context);
trapFile.type_parameter_constraints(constraints, this);
if (Symbol.HasReferenceTypeConstraint)
{
trapFile.general_type_parameter_constraints(constraints, 1);
}
if (Symbol.HasValueTypeConstraint)
{
trapFile.general_type_parameter_constraints(constraints, 2);
}
if (Symbol.HasConstructorConstraint)
{
trapFile.general_type_parameter_constraints(constraints, 3);
}
if (Symbol.HasUnmanagedTypeConstraint)
{
trapFile.general_type_parameter_constraints(constraints, 4);
}
if (Symbol.ReferenceTypeConstraintNullableAnnotation == NullableAnnotation.Annotated)
{
trapFile.general_type_parameter_constraints(constraints, 5);
}
foreach (var abase in Symbol.GetAnnotatedTypeConstraints())
{
var t = Create(Context, abase.Symbol);
trapFile.specific_type_parameter_constraints(constraints, t.TypeRef);
if (!abase.HasObliviousNullability())
{
trapFile.specific_type_parameter_nullability(constraints, t.TypeRef, NullabilityEntity.Create(Context, Nullability.Create(abase)));
}
}
trapFile.types(this, Kinds.TypeKind.TYPE_PARAMETER, Symbol.Name);
var parentNs = Namespace.Create(Context, Symbol.TypeParameterKind == TypeParameterKind.Method ? Context.Compilation.GlobalNamespace : Symbol.ContainingNamespace);
trapFile.parent_namespace(this, parentNs);
foreach (var l in Symbol.Locations)
{
trapFile.type_location(this, Context.CreateLocation(l));
}
if (IsSourceDeclaration)
{
var declSyntaxReferences = Symbol.DeclaringSyntaxReferences
.Select(d => d.GetSyntax())
.Select(s => s.Parent)
.Where(p => p is not null)
.Select(p => p !.Parent)
.ToArray();
var clauses = declSyntaxReferences.OfType <MethodDeclarationSyntax>().SelectMany(m => m.ConstraintClauses);
clauses = clauses.Concat(declSyntaxReferences.OfType <ClassDeclarationSyntax>().SelectMany(c => c.ConstraintClauses));
clauses = clauses.Concat(declSyntaxReferences.OfType <InterfaceDeclarationSyntax>().SelectMany(c => c.ConstraintClauses));
clauses = clauses.Concat(declSyntaxReferences.OfType <StructDeclarationSyntax>().SelectMany(c => c.ConstraintClauses));
foreach (var clause in clauses.Where(c => c.Name.Identifier.Text == Symbol.Name))
{
TypeMention.Create(Context, clause.Name, this, this);
foreach (var constraint in clause.Constraints.OfType <TypeConstraintSyntax>())
{
var ti = Context.GetModel(constraint).GetTypeInfo(constraint.Type);
var target = Type.Create(Context, ti.Type);
TypeMention.Create(Context, constraint.Type, this, target);
}
}
}
}
protected void PopulateType(TextWriter trapFile)
{
PopulateMetadataHandle(trapFile);
PopulateAttributes();
trapFile.Write("types(");
trapFile.WriteColumn(this);
trapFile.Write(',');
trapFile.WriteColumn((int)GetClassType(Context, symbol));
trapFile.Write(",\"");
symbol.BuildDisplayName(Context, trapFile);
trapFile.WriteLine("\")");
// Visit base types
var baseTypes = new List <Type>();
if (symbol.BaseType != null)
{
Type baseKey = Create(Context, symbol.BaseType);
trapFile.extend(this, baseKey.TypeRef);
if (symbol.TypeKind != TypeKind.Struct)
{
baseTypes.Add(baseKey);
}
}
if (symbol.TypeKind == TypeKind.Interface)
{
trapFile.extend(this, Create(Context, Context.Compilation.ObjectType));
}
if (!(base.symbol is IArrayTypeSymbol))
{
foreach (var t in base.symbol.Interfaces.Select(i => Create(Context, i)))
{
trapFile.implement(this, t.TypeRef);
baseTypes.Add(t);
}
}
var containingType = ContainingType;
if (containingType != null && symbol.Kind != SymbolKind.TypeParameter)
{
Type originalDefinition = symbol.TypeKind == TypeKind.Error ? this : Create(Context, symbol.OriginalDefinition);
trapFile.nested_types(this, containingType, originalDefinition);
}
else if (symbol.ContainingNamespace != null)
{
trapFile.parent_namespace(this, Namespace.Create(Context, symbol.ContainingNamespace));
}
if (symbol is IArrayTypeSymbol)
{
// They are in the namespace of the original object
ITypeSymbol elementType = ((IArrayTypeSymbol)symbol).ElementType;
INamespaceSymbol ns = elementType.TypeKind == TypeKind.TypeParameter ? Context.Compilation.GlobalNamespace : elementType.ContainingNamespace;
if (ns != null)
{
trapFile.parent_namespace(this, Namespace.Create(Context, ns));
}
}
if (symbol is IPointerTypeSymbol)
{
ITypeSymbol elementType = ((IPointerTypeSymbol)symbol).PointedAtType;
INamespaceSymbol ns = elementType.TypeKind == TypeKind.TypeParameter ? Context.Compilation.GlobalNamespace : elementType.ContainingNamespace;
if (ns != null)
{
trapFile.parent_namespace(this, Namespace.Create(Context, ns));
}
}
if (symbol.BaseType != null && symbol.BaseType.SpecialType == SpecialType.System_MulticastDelegate)
{
// This is a delegate.
// The method "Invoke" has the return type.
var invokeMethod = ((INamedTypeSymbol)symbol).DelegateInvokeMethod;
// Copy the parameters from the "Invoke" method to the delegate type
for (var i = 0; i < invokeMethod.Parameters.Length; ++i)
{
var param = invokeMethod.Parameters[i];
var originalParam = invokeMethod.OriginalDefinition.Parameters[i];
var originalParamEntity = SymbolEqualityComparer.Default.Equals(param, originalParam) ? null :
DelegateTypeParameter.Create(Context, originalParam, Create(Context, ((INamedTypeSymbol)symbol).OriginalDefinition));
DelegateTypeParameter.Create(Context, param, this, originalParamEntity);
}
var returnKey = Create(Context, invokeMethod.ReturnType);
trapFile.delegate_return_type(this, returnKey.TypeRef);
if (invokeMethod.ReturnsByRef)
{
trapFile.type_annotation(this, Kinds.TypeAnnotation.Ref);
}
if (invokeMethod.ReturnsByRefReadonly)
{
trapFile.type_annotation(this, Kinds.TypeAnnotation.ReadonlyRef);
}
}
Modifier.ExtractModifiers(Context, trapFile, this, symbol);
if (IsSourceDeclaration && symbol.FromSource())
{
var declSyntaxReferences = symbol.DeclaringSyntaxReferences.Select(d => d.GetSyntax()).ToArray();
var baseLists = declSyntaxReferences.OfType <ClassDeclarationSyntax>().Select(c => c.BaseList);
baseLists = baseLists.Concat(declSyntaxReferences.OfType <InterfaceDeclarationSyntax>().Select(c => c.BaseList));
baseLists = baseLists.Concat(declSyntaxReferences.OfType <StructDeclarationSyntax>().Select(c => c.BaseList));
baseLists.
Where(bl => bl != null).
SelectMany(bl => bl.Types).
Zip(baseTypes.Where(bt => bt.symbol.SpecialType != SpecialType.System_Object),
(s, t) => TypeMention.Create(Context, s.Type, this, t)).
Enumerate();
}
}
public override void Populate(TextWriter trapFile)
{
PopulateMetadataHandle(trapFile);
PopulateAttributes();
PopulateModifiers(trapFile);
BindComments();
PopulateNullability(trapFile, symbol.GetAnnotatedType());
PopulateRefKind(trapFile, symbol.RefKind);
var type = Type;
trapFile.properties(this, symbol.GetName(), ContainingType, type.TypeRef, Create(Context, symbol.OriginalDefinition));
var getter = symbol.GetMethod;
var setter = symbol.SetMethod;
if (!(getter is null))
{
Method.Create(Context, getter);
}
if (!(setter is null))
{
Method.Create(Context, setter);
}
var declSyntaxReferences = IsSourceDeclaration ?
symbol.DeclaringSyntaxReferences.
Select(d => d.GetSyntax()).OfType <PropertyDeclarationSyntax>().ToArray()
: Enumerable.Empty <PropertyDeclarationSyntax>();
foreach (var explicitInterface in symbol.ExplicitInterfaceImplementations.Select(impl => Type.Create(Context, impl.ContainingType)))
{
trapFile.explicitly_implements(this, explicitInterface.TypeRef);
foreach (var syntax in declSyntaxReferences)
{
TypeMention.Create(Context, syntax.ExplicitInterfaceSpecifier.Name, this, explicitInterface);
}
}
foreach (var l in Locations)
{
trapFile.property_location(this, l);
}
if (IsSourceDeclaration && symbol.FromSource())
{
var expressionBody = ExpressionBody;
if (expressionBody != null)
{
Context.PopulateLater(() => Expression.Create(Context, expressionBody, this, 0));
}
var child = 1;
foreach (var initializer in declSyntaxReferences
.Select(n => n.Initializer)
.Where(i => i != null))
{
Context.PopulateLater(() =>
{
var loc = Context.CreateLocation(initializer.GetLocation());
var annotatedType = AnnotatedTypeSymbol.CreateNotAnnotated(symbol.Type);
var simpleAssignExpr = new Expression(new ExpressionInfo(Context, annotatedType, loc, ExprKind.SIMPLE_ASSIGN, this, child++, false, null));
Expression.CreateFromNode(new ExpressionNodeInfo(Context, initializer.Value, simpleAssignExpr, 0));
var access = new Expression(new ExpressionInfo(Context, annotatedType, Location, ExprKind.PROPERTY_ACCESS, simpleAssignExpr, 1, false, null));
trapFile.expr_access(access, this);
if (!symbol.IsStatic)
{
This.CreateImplicit(Context, symbol.ContainingType, Location, access, -1);
}
});
}
foreach (var syntax in declSyntaxReferences)
{
TypeMention.Create(Context, syntax.Type, this, type);
}
}
}
public override void Populate()
{
ExtractAttributes();
ExtractModifiers();
BindComments();
var type = Type.Create(Context, symbol.Type);
Context.Emit(Tuples.properties(this, symbol.GetName(), ContainingType, type.TypeRef, Create(Context, symbol.OriginalDefinition)));
var getter = symbol.GetMethod;
if (getter != null)
{
Getter = Accessor.Create(Context, getter);
}
var setter = symbol.SetMethod;
if (setter != null)
{
Setter = Accessor.Create(Context, setter);
}
var declSyntaxReferences = IsSourceDeclaration ?
symbol.DeclaringSyntaxReferences.
Select(d => d.GetSyntax()).OfType <PropertyDeclarationSyntax>().ToArray()
: Enumerable.Empty <PropertyDeclarationSyntax>();
foreach (var explicitInterface in symbol.ExplicitInterfaceImplementations.Select(impl => Type.Create(Context, impl.ContainingType)))
{
Context.Emit(Tuples.explicitly_implements(this, explicitInterface.TypeRef));
foreach (var syntax in declSyntaxReferences)
{
TypeMention.Create(Context, syntax.ExplicitInterfaceSpecifier.Name, this, explicitInterface);
}
}
foreach (var l in Locations)
{
Context.Emit(Tuples.property_location(this, l));
}
if (IsSourceDeclaration && symbol.FromSource())
{
var expressionBody = ExpressionBody;
if (expressionBody != null)
{
Context.PopulateLater(() => Expression.Create(Context, expressionBody, this, 0));
}
foreach (var initializer in declSyntaxReferences.
Select(n => n.Initializer).
Where(i => i != null).
Select(i => i.Value))
{
Context.PopulateLater(() => Expression.Create(Context, initializer, this, 1));
}
foreach (var syntax in declSyntaxReferences)
{
TypeMention.Create(Context, syntax.Type, this, type);
}
}
}
public override void Populate(TextWriter trapFile)
{
PopulateAttributes();
PopulateNullability(trapFile, symbol.GetAnnotatedType());
PopulateRefKind(trapFile, symbol.RefKind);
if (symbol.Name != Original.symbol.Name)
{
Context.ModelError(symbol, "Inconsistent parameter declaration");
}
var type = Type.Create(Context, symbol.Type);
trapFile.@params(this, Name, type.TypeRef, Ordinal, ParamKind, Parent, Original);
foreach (var l in symbol.Locations)
{
trapFile.param_location(this, Context.Create(l));
}
if (!IsSourceDeclaration || !symbol.FromSource())
{
return;
}
BindComments();
if (IsSourceDeclaration)
{
foreach (var syntax in symbol.DeclaringSyntaxReferences.
Select(d => d.GetSyntax()).
OfType <ParameterSyntax>().
Where(s => s.Type != null))
{
TypeMention.Create(Context, syntax.Type, this, type);
}
}
if (symbol.HasExplicitDefaultValue && Context.Defines(symbol))
{
// This is a slight bug in the dbscheme
// We should really define param_default(param, string)
// And use parameter child #0 to encode the default expression.
var defaultValue = GetParameterDefaultValue(symbol);
if (defaultValue == null)
{
// In case this parameter belongs to an accessor of an indexer, we need
// to get the default value from the corresponding parameter belonging
// to the indexer itself
var method = (IMethodSymbol)symbol.ContainingSymbol;
if (method != null)
{
var i = method.Parameters.IndexOf(symbol);
var indexer = (IPropertySymbol)method.AssociatedSymbol;
if (indexer != null)
{
defaultValue = GetParameterDefaultValue(indexer.Parameters[i]);
}
}
}
if (defaultValue != null)
{
Context.PopulateLater(() =>
{
Expression.Create(Context, defaultValue.Value, this, 0);
});
}
}
}
protected void PopulateType(TextWriter trapFile, bool constructUnderlyingTupleType = false)
{
PopulateMetadataHandle(trapFile);
PopulateAttributes();
trapFile.Write("types(");
trapFile.WriteColumn(this);
trapFile.Write(',');
trapFile.WriteColumn((int)GetClassType(Context, symbol, constructUnderlyingTupleType));
trapFile.Write(",\"");
symbol.BuildDisplayName(Context, trapFile, constructUnderlyingTupleType);
trapFile.WriteLine("\")");
// Visit base types
var baseTypes = new List <Type>();
if (symbol.GetNonObjectBaseType(Context) is INamedTypeSymbol @base)
{
var baseKey = Create(Context, @base);
trapFile.extend(this, baseKey.TypeRef);
if (symbol.TypeKind != TypeKind.Struct)
{
baseTypes.Add(baseKey);
}
}
if (!(base.symbol is IArrayTypeSymbol))
{
foreach (var t in base.symbol.Interfaces.Select(i => Create(Context, i)))
{
trapFile.implement(this, t.TypeRef);
baseTypes.Add(t);
}
}
var containingType = ContainingType;
if (containingType != null && symbol.Kind != SymbolKind.TypeParameter)
{
var originalDefinition = symbol.TypeKind == TypeKind.Error ? this : Create(Context, symbol.OriginalDefinition);
trapFile.nested_types(this, containingType, originalDefinition);
}
else if (symbol.ContainingNamespace != null)
{
trapFile.parent_namespace(this, Namespace.Create(Context, symbol.ContainingNamespace));
}
if (symbol is IArrayTypeSymbol array)
{
// They are in the namespace of the original object
var elementType = array.ElementType;
var ns = elementType.TypeKind == TypeKind.TypeParameter ? Context.Compilation.GlobalNamespace : elementType.ContainingNamespace;
if (ns != null)
{
trapFile.parent_namespace(this, Namespace.Create(Context, ns));
}
}
if (symbol is IPointerTypeSymbol pointer)
{
var elementType = pointer.PointedAtType;
var ns = elementType.TypeKind == TypeKind.TypeParameter ? Context.Compilation.GlobalNamespace : elementType.ContainingNamespace;
if (ns != null)
{
trapFile.parent_namespace(this, Namespace.Create(Context, ns));
}
}
if (symbol.BaseType != null && symbol.BaseType.SpecialType == SpecialType.System_MulticastDelegate)
{
// This is a delegate.
// The method "Invoke" has the return type.
var invokeMethod = ((INamedTypeSymbol)symbol).DelegateInvokeMethod;
ExtractParametersForDelegateLikeType(trapFile, invokeMethod,
t => trapFile.delegate_return_type(this, t));
}
if (symbol is IFunctionPointerTypeSymbol functionPointer)
{
ExtractParametersForDelegateLikeType(trapFile, functionPointer.Signature,
t => trapFile.function_pointer_return_type(this, t));
}
Modifier.ExtractModifiers(Context, trapFile, this, symbol);
if (IsSourceDeclaration && symbol.FromSource())
{
var declSyntaxReferences = symbol.DeclaringSyntaxReferences.Select(d => d.GetSyntax()).ToArray();
var baseLists = declSyntaxReferences.OfType <ClassDeclarationSyntax>().Select(c => c.BaseList);
baseLists = baseLists.Concat(declSyntaxReferences.OfType <InterfaceDeclarationSyntax>().Select(c => c.BaseList));
baseLists = baseLists.Concat(declSyntaxReferences.OfType <StructDeclarationSyntax>().Select(c => c.BaseList));
baseLists
.Where(bl => bl != null)
.SelectMany(bl => bl.Types)
.Zip(
baseTypes.Where(bt => bt.symbol.SpecialType != SpecialType.System_Object),
(s, t) => TypeMention.Create(Context, s.Type, this, t))
.Enumerate();
}
}
public override void Populate(TextWriter trapFile)
{
PopulateMetadataHandle(trapFile);
PopulateAttributes();
ContainingType !.PopulateGenerics();
PopulateNullability(trapFile, Symbol.GetAnnotatedType());
var unboundFieldKey = Field.Create(Context, Symbol.OriginalDefinition);
trapFile.fields(this, (Symbol.IsConst ? 2 : 1), Symbol.Name, ContainingType, Type.TypeRef, unboundFieldKey);
PopulateModifiers(trapFile);
if (Symbol.IsVolatile)
{
Modifier.HasModifier(Context, trapFile, this, "volatile");
}
if (Symbol.IsConst)
{
Modifier.HasModifier(Context, trapFile, this, "const");
if (Symbol.HasConstantValue)
{
trapFile.constant_value(this, Expression.ValueAsString(Symbol.ConstantValue));
}
}
foreach (var l in Locations)
{
trapFile.field_location(this, l);
}
if (!IsSourceDeclaration || !Symbol.FromSource())
{
return;
}
Context.BindComments(this, Location.Symbol);
var child = 0;
foreach (var initializer in Symbol.DeclaringSyntaxReferences
.Select(n => n.GetSyntax())
.OfType <VariableDeclaratorSyntax>()
.Where(n => n.Initializer is not null))
{
Context.PopulateLater(() =>
{
var loc = Context.CreateLocation(initializer.GetLocation());
var fieldAccess = AddInitializerAssignment(trapFile, initializer.Initializer !.Value, loc, null, ref child);
if (!Symbol.IsStatic)
{
This.CreateImplicit(Context, Symbol.ContainingType, Location, fieldAccess, -1);
}
});
}
foreach (var initializer in Symbol.DeclaringSyntaxReferences
.Select(n => n.GetSyntax())
.OfType <EnumMemberDeclarationSyntax>()
.Where(n => n.EqualsValue is not null))
{
// Mark fields that have explicit initializers.
var constValue = Symbol.HasConstantValue
? Expression.ValueAsString(Symbol.ConstantValue)
: null;
var loc = Context.CreateLocation(initializer.GetLocation());
AddInitializerAssignment(trapFile, initializer.EqualsValue !.Value, loc, constValue, ref child);
}
if (IsSourceDeclaration)
{
foreach (var syntax in Symbol.DeclaringSyntaxReferences
.Select(d => d.GetSyntax())
.OfType <VariableDeclaratorSyntax>()
.Select(d => d.Parent)
.OfType <VariableDeclarationSyntax>())
{
TypeMention.Create(Context, syntax.Type, this, Type);
}
}
}
public override void Populate()
{
var constraints = new TypeParameterConstraints(Context);
Context.Emit(Tuples.type_parameter_constraints(constraints, this));
if (symbol.HasReferenceTypeConstraint)
{
Context.Emit(Tuples.general_type_parameter_constraints(constraints, 1));
}
if (symbol.HasValueTypeConstraint)
{
Context.Emit(Tuples.general_type_parameter_constraints(constraints, 2));
}
if (symbol.HasConstructorConstraint)
{
Context.Emit(Tuples.general_type_parameter_constraints(constraints, 3));
}
ITypeSymbol baseType = symbol.HasValueTypeConstraint ?
Context.Compilation.GetTypeByMetadataName(valueTypeName) :
Context.Compilation.ObjectType;
foreach (var abase in symbol.ConstraintTypes)
{
if (abase.TypeKind != TypeKind.Interface)
{
baseType = abase;
}
var t = Create(Context, abase);
Context.Emit(Tuples.specific_type_parameter_constraints(constraints, t.TypeRef));
}
Context.Emit(Tuples.types(this, Semmle.Extraction.Kinds.TypeKind.TYPE_PARAMETER, symbol.Name));
Context.Emit(Tuples.extend(this, Create(Context, baseType).TypeRef));
Namespace parentNs = Namespace.Create(Context, symbol.TypeParameterKind == TypeParameterKind.Method ? Context.Compilation.GlobalNamespace : symbol.ContainingNamespace);
Context.Emit(Tuples.parent_namespace(this, parentNs));
foreach (var l in symbol.Locations)
{
Context.Emit(Tuples.type_location(this, Context.Create(l)));
}
if (this.IsSourceDeclaration)
{
var declSyntaxReferences = symbol.DeclaringSyntaxReferences.Select(d => d.GetSyntax()).
Select(s => s.Parent).Where(p => p != null).Select(p => p.Parent).ToArray();
var clauses = declSyntaxReferences.OfType <MethodDeclarationSyntax>().SelectMany(m => m.ConstraintClauses);
clauses = clauses.Concat(declSyntaxReferences.OfType <ClassDeclarationSyntax>().SelectMany(c => c.ConstraintClauses));
clauses = clauses.Concat(declSyntaxReferences.OfType <InterfaceDeclarationSyntax>().SelectMany(c => c.ConstraintClauses));
clauses = clauses.Concat(declSyntaxReferences.OfType <StructDeclarationSyntax>().SelectMany(c => c.ConstraintClauses));
foreach (var clause in clauses.Where(c => c.Name.Identifier.Text == symbol.Name))
{
TypeMention.Create(Context, clause.Name, this, this);
foreach (var constraint in clause.Constraints.OfType <TypeConstraintSyntax>())
{
var ti = Context.Model(constraint).GetTypeInfo(constraint.Type);
var target = Type.Create(Context, ti.Type);
TypeMention.Create(Context, constraint.Type, this, target);
}
}
}
}
public override void Populate(TextWriter trapFile)
{
PopulateMetadataHandle(trapFile);
PopulateAttributes();
ContainingType.PopulateGenerics();
PopulateNullability(trapFile, symbol.NullableAnnotation);
Field unboundFieldKey = Field.Create(Context, symbol.OriginalDefinition);
trapFile.fields(this, (symbol.IsConst ? 2 : 1), symbol.Name, ContainingType, Type.Type.TypeRef, unboundFieldKey);
PopulateModifiers(trapFile);
if (symbol.IsVolatile)
{
Modifier.HasModifier(Context, trapFile, this, "volatile");
}
if (symbol.IsConst)
{
Modifier.HasModifier(Context, trapFile, this, "const");
if (symbol.HasConstantValue)
{
trapFile.constant_value(this, Expression.ValueAsString(symbol.ConstantValue));
}
}
foreach (var l in Locations)
{
trapFile.field_location(this, l);
}
if (!IsSourceDeclaration || !symbol.FromSource())
{
return;
}
Context.BindComments(this, Location.symbol);
int child = 0;
foreach (var initializer in
symbol.DeclaringSyntaxReferences.
Select(n => n.GetSyntax()).
OfType <VariableDeclaratorSyntax>().
Where(n => n.Initializer != null))
{
Context.PopulateLater(() =>
{
var loc = Context.Create(initializer.GetLocation());
var simpleAssignExpr = new Expression(new ExpressionInfo(Context, Type, loc, ExprKind.SIMPLE_ASSIGN, this, child++, false, null));
Expression.CreateFromNode(new ExpressionNodeInfo(Context, initializer.Initializer.Value, simpleAssignExpr, 0));
var access = new Expression(new ExpressionInfo(Context, Type, Location, ExprKind.FIELD_ACCESS, simpleAssignExpr, 1, false, null));
trapFile.expr_access(access, this);
if (!symbol.IsStatic)
{
This.CreateImplicit(Context, Entities.Type.Create(Context, symbol.ContainingType), Location, access, -1);
}
});
}
foreach (var initializer in symbol.DeclaringSyntaxReferences.
Select(n => n.GetSyntax()).
OfType <EnumMemberDeclarationSyntax>().
Where(n => n.EqualsValue != null))
{
// Mark fields that have explicit initializers.
var expr = new Expression(new ExpressionInfo(Context, Type, Context.Create(initializer.EqualsValue.Value.FixedLocation()), Kinds.ExprKind.FIELD_ACCESS, this, child++, false, null));
trapFile.expr_access(expr, this);
}
if (IsSourceDeclaration)
{
foreach (var syntax in symbol.DeclaringSyntaxReferences.
Select(d => d.GetSyntax()).OfType <VariableDeclaratorSyntax>().
Select(d => d.Parent).OfType <VariableDeclarationSyntax>())
{
TypeMention.Create(Context, syntax.Type, this, Type);
}
}
}
public override void Populate(TextWriter trapFile)
{
PopulateNullability(trapFile, symbol.GetAnnotatedType());
var type = Type.Create(Context, symbol.Type);
trapFile.indexers(this, symbol.GetName(useMetadataName: true), ContainingType, type.TypeRef, OriginalDefinition);
foreach (var l in Locations)
{
trapFile.indexer_location(this, l);
}
var getter = symbol.GetMethod;
var setter = symbol.SetMethod;
if (getter is null && setter is null)
{
Context.ModelError(symbol, "No indexer accessor defined");
}
if (!(getter is null))
{
Method.Create(Context, getter);
}
if (!(setter is null))
{
Method.Create(Context, setter);
}
for (var i = 0; i < symbol.Parameters.Length; ++i)
{
var original = Parameter.Create(Context, symbol.OriginalDefinition.Parameters[i], OriginalDefinition);
Parameter.Create(Context, symbol.Parameters[i], this, original);
}
if (IsSourceDeclaration)
{
var expressionBody = ExpressionBody;
if (expressionBody != null)
{
// The expression may need to reference parameters in the getter.
// So we need to arrange that the expression is populated after the getter.
Context.PopulateLater(() => Expression.CreateFromNode(new ExpressionNodeInfo(Context, expressionBody, this, 0)
{
Type = Type.Create(Context, symbol.GetAnnotatedType())
}));
}
}
PopulateModifiers(trapFile);
BindComments();
var declSyntaxReferences = IsSourceDeclaration
? symbol.DeclaringSyntaxReferences.
Select(d => d.GetSyntax()).OfType <IndexerDeclarationSyntax>().ToArray()
: Enumerable.Empty <IndexerDeclarationSyntax>();
foreach (var explicitInterface in symbol.ExplicitInterfaceImplementations.Select(impl => Type.Create(Context, impl.ContainingType)))
{
trapFile.explicitly_implements(this, explicitInterface.TypeRef);
foreach (var syntax in declSyntaxReferences)
{
TypeMention.Create(Context, syntax.ExplicitInterfaceSpecifier.Name, this, explicitInterface);
}
}
foreach (var syntax in declSyntaxReferences)
{
TypeMention.Create(Context, syntax.Type, this, type);
}
}
public override void Populate()
{
ExtractMetadataHandle();
ExtractAttributes();
ContainingType.ExtractGenerics();
Field unboundFieldKey = Field.Create(Context, symbol.OriginalDefinition);
Context.Emit(Tuples.fields(this, (symbol.IsConst ? 2 : 1), symbol.Name, ContainingType, Type.TypeRef, unboundFieldKey));
ExtractModifiers();
if (symbol.IsVolatile)
{
Modifier.HasModifier(Context, this, "volatile");
}
if (symbol.IsConst)
{
Modifier.HasModifier(Context, this, "const");
if (symbol.HasConstantValue)
{
Context.Emit(Tuples.constant_value(this, Expression.ValueAsString(symbol.ConstantValue)));
}
}
foreach (var l in Locations)
{
Context.Emit(Tuples.field_location(this, l));
}
if (!IsSourceDeclaration || !symbol.FromSource())
{
return;
}
Context.BindComments(this, Location.symbol);
int child = 0;
foreach (var initializer in
symbol.DeclaringSyntaxReferences.
Select(n => n.GetSyntax()).
OfType <VariableDeclaratorSyntax>().
Where(n => n.Initializer != null))
{
Context.PopulateLater(() =>
{
Expression.CreateFromNode(new ExpressionNodeInfo(Context, initializer.Initializer.Value, this, child++));
});
}
foreach (var initializer in symbol.DeclaringSyntaxReferences.
Select(n => n.GetSyntax()).
OfType <EnumMemberDeclarationSyntax>().
Where(n => n.EqualsValue != null))
{
// Mark fields that have explicit initializers.
var expr = new Expression(new ExpressionInfo(Context, Type, Context.Create(initializer.EqualsValue.Value.FixedLocation()), Kinds.ExprKind.FIELD_ACCESS, this, child++, false, null));
Context.Emit(Tuples.expr_access(expr, this));
}
if (IsSourceDeclaration)
{
foreach (var syntax in symbol.DeclaringSyntaxReferences.
Select(d => d.GetSyntax()).OfType <VariableDeclaratorSyntax>().
Select(d => d.Parent).OfType <VariableDeclarationSyntax>())
{
TypeMention.Create(Context, syntax.Type, this, Type);
}
}
}
