public BinaryOperatorSignature(BinaryOperatorKind kind, TypeSymbol returnType, TypeSymbol leftParameterType, TypeSymbol rightParameterType)
{
Kind = kind;
ReturnType = returnType;
_leftParameterType = leftParameterType;
_rightParameterType = rightParameterType;
}
public BoundConversionExpression(BoundExpression expression, TypeSymbol type, Conversion conversion)
: base(BoundNodeKind.ConversionExpression)
{
Expression = expression;
Type = type;
Conversion = conversion;
}
public BoundTypeAlias(TypeAliasSymbol typeAliasSymbol, TypeSymbol declaredType, ImmutableArray<BoundVariableQualifier> qualifiers)
: base(BoundNodeKind.TypeAlias)
{
TypeAliasSymbol = typeAliasSymbol;
DeclaredType = declaredType;
Qualifiers = qualifiers;
}
internal ParameterSymbol(string name, string documentation, Symbol parent, TypeSymbol valueType, ParameterDirection direction = ParameterDirection.In)
: base(SymbolKind.Parameter, name, documentation, parent, valueType)
{
if (valueType == null)
throw new ArgumentNullException(nameof(valueType));
Direction = direction;
}
public BoundNumericConstructorInvocationExpression(NumericConstructorInvocationExpressionSyntax syntax, TypeSymbol type, ImmutableArray<BoundExpression> arguments, OverloadResolutionResult<FunctionSymbolSignature> result)
: base(BoundNodeKind.NumericConstructorInvocationExpression)
{
Syntax = syntax;
Type = type;
Arguments = arguments;
Result = result;
}
public BoundVariableDeclaration(VariableSymbol variableSymbol, TypeSymbol declaredType, ImmutableArray<BoundVariableQualifier> qualifiers, BoundInitializer initializerOpt)
: base(BoundNodeKind.VariableDeclaration)
{
VariableSymbol = variableSymbol;
DeclaredType = declaredType;
Qualifiers = qualifiers;
InitializerOpt = initializerOpt;
}
private static OverloadResolutionResult<BinaryOperatorSignature> ResolveOverloads(BinaryOperatorKind kind, TypeSymbol leftOperandType, TypeSymbol rightOperandType)
{
var builtInSignatures = GetBuiltInSignatures(kind);
if (BothTypesBuiltIn(leftOperandType, rightOperandType))
return OverloadResolution.Perform(builtInSignatures, leftOperandType, rightOperandType);
return OverloadResolutionResult<BinaryOperatorSignature>.None;
}
private static OverloadResolutionResult<UnaryOperatorSignature> ResolveOverloads(UnaryOperatorKind kind, TypeSymbol operandType)
{
var builtInSignatures = GetBuiltInSignatures(kind);
if (TypeBuiltIn(operandType))
return OverloadResolution.Perform(builtInSignatures, operandType);
return OverloadResolutionResult<UnaryOperatorSignature>.None;
}
internal ArraySymbol(TypeSymbol valueType, int? dimension)
: base(SymbolKind.Array, $"{valueType.FullName}[{dimension?.ToString() ?? string.Empty}]", "Array of " + valueType.Name, null)
{
foreach (var member in CreateArrayMembers(this, valueType))
AddMember(member);
ValueType = valueType;
Dimension = dimension;
}
internal static bool HasExplicitConversionTo(this TypeSymbol left, TypeSymbol right)
{
if (left.Equals(right))
return true;
if (left.IsIntrinsicNumericType() && right.Kind == SymbolKind.Struct)
return true;
return left.HasImplicitConversionTo(right);
}
private BoundTypeAlias BindTypeAlias(TypeAliasSyntax syntax, TypeSymbol variableType)
{
variableType = BindArrayRankSpecifiers(syntax.ArrayRankSpecifiers, variableType);
var symbol = new TypeAliasSymbol(syntax, variableType);
AddSymbol(symbol, syntax.Identifier.Span);
var boundQualifiers = new List<BoundVariableQualifier>();
foreach (var qualifier in syntax.Qualifiers)
boundQualifiers.Add(Bind(qualifier, BindVariableQualifier));
return new BoundTypeAlias(symbol, variableType, boundQualifiers.ToImmutableArray());
}
internal InvocableSymbol(SymbolKind kind, string name, string documentation, Symbol parent, TypeSymbol returnType, Func<InvocableSymbol, IEnumerable<ParameterSymbol>> lazyParameters = null)
: base(kind, name, documentation, parent)
{
if (returnType == null)
throw new ArgumentNullException(nameof(returnType));
_parameters = new List<ParameterSymbol>();
if (lazyParameters != null)
foreach (var parameter in lazyParameters(this))
AddParameter(parameter);
ReturnType = returnType;
}
internal static Conversion Classify(TypeSymbol sourceType, TypeSymbol targetType, ParameterDirection direction)
{
if (sourceType.Equals(targetType))
return Identity;
// First, make sure we have a conversion from argument to parameter.
switch (direction)
{
case ParameterDirection.In:
if (!sourceType.HasImplicitConversionTo(targetType))
return sourceType.HasExplicitConversionTo(targetType) ? Explicit : None;
break;
case ParameterDirection.Out:
if (!targetType.HasImplicitConversionTo(sourceType))
return None;
break;
case ParameterDirection.Inout:
if (!sourceType.HasImplicitConversionTo(targetType) || !targetType.HasImplicitConversionTo(sourceType))
return None;
break;
default:
throw new ArgumentOutOfRangeException();
}
var conversionType = ConversionTypes.None;
var numericTargetType = targetType as IntrinsicNumericTypeSymbol;
var numericSourceType = sourceType as IntrinsicNumericTypeSymbol;
if (numericTargetType != null && numericSourceType != null)
{
conversionType |= ClassifyTypeConversion(numericSourceType, numericTargetType);
conversionType |= ClassifyDimensionConversion(numericSourceType, numericTargetType);
}
// TODO: Non-numeric implicit conversions.
return new Conversion(true, false, false, conversionType);
}
private void GetTextureValueAndScalarType(PredefinedObjectTypeSyntax node, out TypeSymbol valueType, out ScalarType scalarType)
{
if (node.TemplateArgumentList != null)
{
var valueTypeSyntax = (TypeSyntax) node.TemplateArgumentList.Arguments[0];
valueType = Bind(valueTypeSyntax, x => BindType(x, null)).TypeSymbol;
switch (valueTypeSyntax.Kind)
{
case SyntaxKind.PredefinedScalarType:
scalarType = TypeFacts.GetScalarType((ScalarTypeSyntax) valueTypeSyntax);
break;
case SyntaxKind.PredefinedVectorType:
scalarType = TypeFacts.GetVectorType(((VectorTypeSyntax) valueTypeSyntax).TypeToken.Kind).Item1;
break;
case SyntaxKind.PredefinedGenericVectorType:
scalarType = TypeFacts.GetScalarType(((GenericVectorTypeSyntax) valueTypeSyntax).ScalarType);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
valueType = IntrinsicTypes.Float4;
scalarType = ScalarType.Float;
}
}
private static bool BothTypesBuiltIn(TypeSymbol leftOperandType, TypeSymbol rightOperandType)
{
return leftOperandType.IsIntrinsicNumericType() && rightOperandType.IsIntrinsicNumericType();
}
public BinaryOperatorSignature(BinaryOperatorKind kind, TypeSymbol type)
: this(kind, type, type)
{
}
public static OverloadResolutionResult<BinaryOperatorSignature> Resolve(BinaryOperatorKind kind, TypeSymbol leftOperandType, TypeSymbol rightOperandType)
{
return ResolveOverloads(kind, leftOperandType, rightOperandType);
}
public BinaryOperatorSignature(BinaryOperatorKind kind, TypeSymbol returnType, TypeSymbol parameterType)
: this(kind, returnType, parameterType, parameterType)
{
}
internal TypeAliasSymbol(TypeAliasSyntax syntax, TypeSymbol valueType)
: base(SymbolKind.TypeAlias, syntax.Identifier.Text, string.Empty, null)
{
ValueType = valueType;
}
internal VariableSymbol(SymbolKind kind, string name, string documentation, Symbol parent, TypeSymbol valueType)
: base(kind, name, documentation, parent)
{
ValueType = valueType;
}
public static string GetExpressionTypeString(TypeSymbol type)
{
return SymbolMarkup.ForSymbol(type).ToString();
}
private static IEnumerable<FunctionSymbol> Create4(
string name, string documentation, TypeSymbol[] types,
string parameterName1, string parameterDocumentation1,
string parameterName2, string parameterDocumentation2,
string parameterName3, string parameterDocumentation3,
string parameterName4, string parameterDocumentation4,
TypeSymbol overrideReturnType = null,
ParameterDirection overrideParameterDirection4 = ParameterDirection.In)
{
return types.Select(type => new FunctionSymbol(
name, documentation, null, overrideReturnType ?? type,
f => new[]
{
new ParameterSymbol(parameterName1, parameterDocumentation1, f, type),
new ParameterSymbol(parameterName2, parameterDocumentation2, f, type),
new ParameterSymbol(parameterName3, parameterDocumentation3, f, type),
new ParameterSymbol(parameterName4, parameterDocumentation4, f, type, overrideParameterDirection4)
}));
}
private static IEnumerable<FunctionSymbol> Create1(
string name, string documentation, TypeSymbol[] types,
string parameterName, string parameterDocumentation,
params TypeSymbol[] overrideReturnTypes)
{
if (overrideReturnTypes.Length == 0)
overrideReturnTypes = null;
else if (overrideReturnTypes.Length == 1)
overrideReturnTypes = Enumerable.Repeat(overrideReturnTypes[0], types.Length).ToArray();
return types.Select((type, i) => new FunctionSymbol(
name, documentation, null, overrideReturnTypes?[i] ?? type,
f => new []
{
new ParameterSymbol(parameterName ?? "value", parameterDocumentation ?? "The specified value.", f, type)
}));
}
private BoundMultipleVariableDeclarations BindField(VariableDeclarationStatementSyntax variableDeclarationStatementSyntax, TypeSymbol parentType)
{
var declaration = variableDeclarationStatementSyntax.Declaration;
return BindVariableDeclaration(declaration, parentType, (d, t) => new SourceFieldSymbol(d, parentType, t));
}
private static IEnumerable<Symbol> CreateArrayMembers(TypeSymbol parent, TypeSymbol valueType)
{
yield return new IndexerSymbol("[]", string.Empty, parent, IntrinsicTypes.Uint, valueType);
}
private BoundVariableDeclaration BindVariableDeclarator(VariableDeclaratorSyntax syntax, TypeSymbol variableType, Func<VariableDeclaratorSyntax, TypeSymbol, VariableSymbol> createSymbol)
{
variableType = BindArrayRankSpecifiers(syntax.ArrayRankSpecifiers, variableType);
var symbol = createSymbol(syntax, variableType);
AddSymbol(symbol, syntax.Identifier.Span);
var boundQualifiers = new List<BoundVariableQualifier>();
foreach (var qualifier in syntax.Qualifiers)
boundQualifiers.Add(Bind(qualifier, BindVariableQualifier));
BoundInitializer initializer = null;
if (syntax.Initializer != null)
initializer = BindInitializer(syntax.Initializer);
return new BoundVariableDeclaration(symbol, variableType, boundQualifiers.ToImmutableArray(), initializer);
}
internal VariableSymbol(VariableDeclaratorSyntax syntax, Symbol parent, TypeSymbol valueType)
: base(SymbolKind.Variable, syntax.Identifier.Text, string.Empty, parent)
{
ValueType = valueType;
}
private TypeSymbol BindArrayRankSpecifiers(List<ArrayRankSpecifierSyntax> arrayRankSpecifiers, TypeSymbol variableType)
{
foreach (var arrayRankSpecifier in arrayRankSpecifiers)
{
int? dimension = null;
if (arrayRankSpecifier.Dimension != null)
{
var boundRankSpecifier = Bind(arrayRankSpecifier.Dimension, BindExpression);
if (boundRankSpecifier.Kind == BoundNodeKind.LiteralExpression)
dimension = Convert.ToInt32(((BoundLiteralExpression) boundRankSpecifier).Value);
}
variableType = new ArraySymbol(variableType, dimension);
}
return variableType;
}
internal FunctionSymbol(string name, string documentation, Symbol parent, TypeSymbol returnType, Func<InvocableSymbol, IEnumerable<ParameterSymbol>> lazyParameters = null, bool isNumericConstructor = false)
: base(SymbolKind.Function, name, documentation, parent, returnType, lazyParameters)
{
IsNumericConstructor = isNumericConstructor;
}
private static FunctionSymbol Create0(string name, string documentation, TypeSymbol returnType)
{
return new FunctionSymbol(
name, documentation, null, returnType,
f => new ParameterSymbol[0]);
}
internal SourceFunctionSymbol(FunctionDeclarationSyntax syntax, Symbol parent, TypeSymbol returnType, Func<InvocableSymbol, IEnumerable<ParameterSymbol>> lazyParameters = null)
: base(syntax.Name.GetName(), string.Empty, parent, returnType, lazyParameters)
{
DeclarationSyntaxes = new List<FunctionDeclarationSyntax> { syntax };
}
