public BoundConversionExpression(BoundExpression expression, TypeSymbol type, Conversion conversion) : base(BoundNodeKind.ConversionExpression) { Expression = expression; Type = type; Conversion = conversion; }
public BoundUnaryExpression(SyntaxNode syntax, BoundExpression expression, UnaryOperatorKind operatorKind, TypeSymbol expressionType) : base(BoundNodeKind.UnaryExpression, syntax) { Expression = expression; OperatorKind = operatorKind; Type = expressionType; }
public BinaryOperatorSignature(BinaryOperatorKind kind, TypeSymbol returnType, TypeSymbol leftParameterType, TypeSymbol rightParameterType) { Kind = kind; ReturnType = returnType; _leftParameterType = leftParameterType; _rightParameterType = rightParameterType; }
public BoundVariableDeclaration(VariableDeclarationStatementSyntax syntax, LocalVariableSymbol variableSymbol, TypeSymbol declaredType, BoundExpression initializerOpt) : base(BoundNodeKind.VariableDeclaration, syntax) { VariableSymbol = variableSymbol; DeclaredType = declaredType; InitializerOpt = initializerOpt; }
public BoundNumericConstructorInvocationExpression(NumericConstructorInvocationExpressionSyntax syntax, TypeSymbol type, ImmutableArray<BoundExpression> arguments, OverloadResolutionResult<FunctionSymbolSignature> result) : base(BoundNodeKind.NumericConstructorInvocationExpression) { Syntax = syntax; Type = type; Arguments = arguments; Result = result; }
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 BoundBinaryExpression(BinaryExpressionSyntax syntax, BinaryOperatorKind operatorKind, BoundExpression left, BoundExpression right, TypeSymbol type) : base(BoundNodeKind.BinaryExpression, syntax) { OperatorKind = operatorKind; Left = left; Right = right; Type = type; }
public BoundVariableDeclaration(VariableSymbol variableSymbol, TypeSymbol declaredType, ImmutableArray<BoundVariableQualifier> qualifiers, BoundInitializer initializerOpt) : base(BoundNodeKind.VariableDeclaration) { VariableSymbol = variableSymbol; DeclaredType = declaredType; Qualifiers = qualifiers; InitializerOpt = initializerOpt; }
private static IEnumerable<FunctionDeclarationSymbol> Create1(string name, string documentation, TypeSymbol[] types) { return types.Select(type => new FunctionDeclarationSymbol( name, documentation, type, f => new [] { new ParameterSymbol("value", "The specified value.", f, type) })); }
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 Conversion Classify(TypeSymbol sourceType, TypeSymbol targetType) { if (sourceType == targetType) return Identity; throw new NotImplementedException(); return 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; }
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; }
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); }
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); }
internal static int Compare(TypeSymbol xType, Conversion xConversion, TypeSymbol yType, Conversion yConversion) { if (xConversion.IsIdentity && !yConversion.IsIdentity || xConversion.IsImplicit && yConversion.IsExplicit) return -1; if (!xConversion.IsIdentity && yConversion.IsIdentity || xConversion.IsExplicit && yConversion.IsImplicit) return 1; var xTypeToYType = Classify(xType, yType); var yTypeToXType = Classify(yType, xType); if (xTypeToYType.IsImplicit && yTypeToXType.IsExplicit) return -1; if (xTypeToYType.IsExplicit && yTypeToXType.IsImplicit) return 1; //var xKnown = xType.GetKnownType(); //var yKnown = yType.GetKnownType(); //if (xKnown != null && yKnown != null) //{ // var x = xKnown.Value; // var y = yKnown.Value; // if (x.IsSignedNumericType() && y.IsUnsignedNumericType()) // return -1; // if (x.IsUnsignedNumericType() && y.IsSignedNumericType()) // return 1; //} return 0; }
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 static FunctionSymbol Create0(string name, string documentation, TypeSymbol returnType) { return new FunctionSymbol( name, documentation, null, returnType, f => new ParameterSymbol[0]); }
public static void ReportImplicitTruncation(this ICollection<Diagnostic> diagnostics, TextSpan span, TypeSymbol sourceType, TypeSymbol destinationType) { diagnostics.Report(span, DiagnosticId.ImplicitTruncation, sourceType.Name, destinationType.Name); }
public static void ReportAmbiguousUnaryOperator(this ICollection<Diagnostic> diagnostics, SyntaxToken operatorToken, TypeSymbol type) { var operatorName = operatorToken.Text; var typeName = type.ToDisplayName(); diagnostics.Report(operatorToken.Span, DiagnosticId.AmbiguousUnaryOperator, operatorName, typeName); }
public static void ReportAmbiguousBinaryOperator(this ICollection<Diagnostic> diagnostics, SyntaxToken operatorToken, TypeSymbol leftType, TypeSymbol rightType) { var operatorName = operatorToken.Text; var leftTypeName = leftType.ToDisplayName(); var rightTypeName = rightType.ToDisplayName(); diagnostics.Report(operatorToken.Span, DiagnosticId.AmbiguousBinaryOperator, operatorName, leftTypeName, rightTypeName); }
public static void ReportCannotConvert(this ICollection<Diagnostic> diagnostics, TextSpan span, TypeSymbol sourceType, TypeSymbol targetType) { var sourceTypeName = sourceType.ToDisplayName(); var targetTypeName = targetType.ToDisplayName(); diagnostics.Report(span, DiagnosticId.CannotConvert, sourceTypeName, targetTypeName); }
public static void ReportUndeclaredIndexer(this ICollection<Diagnostic> diagnostics, ElementAccessExpressionSyntax node, TypeSymbol declaringType, IEnumerable<TypeSymbol> argumentTypes) { var declaringTypeName = declaringType.ToDisplayName(); var argumentTypeNames = string.Join(@", ", argumentTypes.Select(t => t.ToDisplayName())); diagnostics.Report(node.GetTextSpanRoot(), DiagnosticId.UndeclaredIndexer, declaringTypeName, argumentTypeNames); }
public static void ReportUndeclaredMethod(this ICollection<Diagnostic> diagnostics, MethodInvocationExpressionSyntax node, TypeSymbol declaringType, IEnumerable<TypeSymbol> argumentTypes) { var name = node.Name.ValueText; var declaringTypeName = declaringType.ToDisplayName(); var argumentTypeNames = string.Join(@", ", argumentTypes.Select(t => t.ToDisplayName())); diagnostics.Report(node.GetTextSpanRoot(), DiagnosticId.UndeclaredMethod, declaringTypeName, name, argumentTypeNames); }
public SourceFunctionDefinitionSymbol(FunctionDefinitionSyntax syntax, TypeSymbol returnType, Func<FunctionSymbol, IEnumerable<ParameterSymbol>> lazyParameters) : base(syntax.Name.GetName(), string.Empty, returnType, lazyParameters) { Syntax = syntax; }
public bool IsSymbol(TypeSymbol symbol, string symbolName) { return (((ISymbolTable)this).FindSymbol(symbolName, null) == symbol); }
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) })); }
public MethodDeclarationSymbol(string name, string documentation, TypeSymbol parent, TypeSymbol returnType, Func<MethodSymbol, IEnumerable<ParameterSymbol>> lazyParameters) : base(SymbolKind.MethodDeclaration, name, documentation, parent, returnType, lazyParameters) { }
public static void ReportUndeclaredField(this ICollection<Diagnostic> diagnostics, FieldAccessExpressionSyntax node, TypeSymbol type) { var typeName = type.ToDisplayName(); var propertyName = node.Name.ValueText; diagnostics.Report(node.GetTextSpanSafe(), DiagnosticId.UndeclaredField, typeName, propertyName); }