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 }; }