Exemplo n.º 1
0
        protected override Conversion GetExplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, ref HashSet <DiagnosticInfo> useSiteDiagnostics, bool forCast)
        {
            var arguments = source.Arguments;

            // check if the type is actually compatible type for a tuple of given cardinality
            if (!destination.IsTupleOrCompatibleWithTupleOfCardinality(arguments.Length))
            {
                return(Conversion.NoConversion);
            }

            ImmutableArray <TypeSymbol> targetElementTypes = destination.GetElementTypesOfTupleOrCompatible();

            Debug.Assert(arguments.Length == targetElementTypes.Length);

            // check arguments against flattened list of target element types
            var argumentConversions = ArrayBuilder <Conversion> .GetInstance(arguments.Length);

            for (int i = 0; i < arguments.Length; i++)
            {
                var result = ClassifyConversionFromExpression(arguments[i], targetElementTypes[i], ref useSiteDiagnostics, forCast);
                if (!result.Exists)
                {
                    argumentConversions.Free();
                    return(Conversion.NoConversion);
                }

                argumentConversions.Add(result);
            }

            return(new Conversion(ConversionKind.ExplicitTupleLiteral, argumentConversions.ToImmutableAndFree()));
        }
Exemplo n.º 2
0
        protected override bool HasImplicitTupleLiteralConversion(BoundExpression source, TypeSymbol destination, ref HashSet <DiagnosticInfo> useSiteDiagnostics)
        {
            if (source.Kind != BoundKind.TupleLiteral)
            {
                // source must be a tuple literal with no conversions
                return(false);
            }

            var tupleExpression = (BoundTupleLiteral)source;
            var arguments       = tupleExpression.Arguments;

            // check if the type is actually compatible type for a tuple of given cardinality
            if (!destination.IsTupleOrCompatibleWithTupleOfCardinality(arguments.Length))
            {
                return(false);
            }

            ImmutableArray <TypeSymbol> targetElementTypes = destination.GetElementTypesOfTupleOrCompatible();

            Debug.Assert(arguments.Length == targetElementTypes.Length);

            // check arguments against flattened list of target element types
            for (int i = 0; i < arguments.Length; i++)
            {
                var argument = arguments[i];
                var result   = ClassifyImplicitConversionFromExpression(argument, targetElementTypes[i], ref useSiteDiagnostics);
                if (!result.Exists)
                {
                    return(false);
                }
            }

            return(true);
        }
Exemplo n.º 3
0
        protected override Conversion GetImplicitTupleLiteralConversion(BoundTupleLiteral source, TypeSymbol destination, ref HashSet<DiagnosticInfo> useSiteDiagnostics)
        {
            var arguments = source.Arguments;

            // check if the type is actually compatible type for a tuple of given cardinality
            if (!destination.IsTupleOrCompatibleWithTupleOfCardinality(arguments.Length))
            {
                return Conversion.NoConversion;
            }

            ImmutableArray<TypeSymbol> targetElementTypes = destination.GetElementTypesOfTupleOrCompatible();
            Debug.Assert(arguments.Length == targetElementTypes.Length);

            // check arguments against flattened list of target element types 
            var argumentConversions = ArrayBuilder<Conversion>.GetInstance(arguments.Length);
            for (int i = 0; i < arguments.Length; i++)
            {
                var argument = arguments[i];
                var result = ClassifyImplicitConversionFromExpression(argument, targetElementTypes[i], ref useSiteDiagnostics);
                if (!result.Exists)
                {
                    argumentConversions.Free();
                    return Conversion.NoConversion;
                }

                argumentConversions.Add(result);
            }

            return new Conversion(ConversionKind.ImplicitTupleLiteral, argumentConversions.ToImmutableAndFree());
        }