Exemple #1
0
        public override void VisitArrayInitializer(IArrayInitializer operation)
        {
            LogString(nameof(IArrayInitializer));
            LogCommonPropertiesAndNewLine(operation);

            VisitArray(operation.ElementValues, "Element Values", logElementCount: true);
        }
        public override void VisitArrayInitializer(IArrayInitializer operation)
        {
            LogString(nameof(IArrayInitializer));
            LogCommonPropertiesAndNewLine(operation);

            base.VisitArrayInitializer(operation);
        }
        private static void CheckArrayInitializer([NotNull] IArrayInitializer arrayInitializer, [NotNull] IHighlightingConsumer consumer)
        {
            ITreeNode start = null, end = null;
            var       variableDeclaration = LocalVariableDeclarationNavigator.GetByInitial(arrayInitializer);

            if (variableDeclaration?.EquivalenceSign != null)
            {
                start = variableDeclaration.NameIdentifier;
                end   = variableDeclaration.EquivalenceSign;
            }
            else
            {
                var fieldDeclaration = FieldDeclarationNavigator.GetByInitial(arrayInitializer);
                if (fieldDeclaration?.EquivalenceSign != null)
                {
                    start = fieldDeclaration.NameIdentifier;
                    end   = fieldDeclaration.EquivalenceSign;
                }
            }

            if (start != null && end != null)
            {
                var endOffset     = end.GetDocumentEndOffset();
                var highlighting  = new ObjectAllocationEvidentHighlighting(arrayInitializer, "array instantiation");
                var documentRange = start.GetDocumentRange().SetEndTo(endOffset);

                consumer.AddHighlighting(highlighting, documentRange);
            }
        }
 internal ArrayWithDefaultValuesInitializationSuggestion(
     [NotNull] string message,
     [CanBeNull] string suggestedCode,
     [NotNull] IArrayInitializer arrayInitializer) : base(message)
 {
     SuggestedCode    = suggestedCode;
     ArrayInitializer = arrayInitializer;
 }
 internal ArrayWithDefaultValuesInitializationHighlighting(
     [NotNull] string message,
     [NotNull] IArrayInitializer arrayInitializer,
     [NotNull] IType arrayElementType,
     int elementCount) : base(message)
 {
     ArrayInitializer = arrayInitializer;
     ArrayElementType = arrayElementType;
     ElementCount     = elementCount;
 }
Exemple #6
0
        static bool IsInvalidInitializer(IArrayInitializer initializer)
        {
            switch (initializer.ArrayClass)
            {
            case ArrayInitializerKind.Dimension:
                foreach (IArrayInitializer element in ((IDimensionArrayInitializer)initializer).ElementValues)
                {
                    if (IsInvalidInitializer(element))
                    {
                        return(true);
                    }
                }

                break;

            case ArrayInitializerKind.Expression:
                return(((IExpressionArrayInitializer)initializer).ElementValue.IsInvalid);
            }

            return(false);
        }
        public override void Initialize(AnalysisContext analysisContext)
        {
            analysisContext.RegisterCompilationStartAction(compilationContext =>
            {
                var formatInfo = new StringFormatInfo(compilationContext.Compilation);

                compilationContext.RegisterOperationAction(operationContext =>
                {
                    var invocation = (IInvocationExpression)operationContext.Operation;

                    StringFormatInfo.Info info = formatInfo.TryGet(invocation.TargetMethod);
                    if (info == null || invocation.ArgumentsInParameterOrder.Length <= info.FormatStringIndex)
                    {
                        // not a target method
                        return;
                    }

                    IArgument formatStringArgument = invocation.ArgumentsInParameterOrder[info.FormatStringIndex];
                    if (!object.Equals(formatStringArgument?.Value?.Type, formatInfo.String) ||
                        !(formatStringArgument?.Value?.ConstantValue.Value is string))
                    {
                        // wrong argument
                        return;
                    }

                    var stringFormat = (string)formatStringArgument.Value.ConstantValue.Value;
                    int expectedStringFormatArgumentCount = GetFormattingArguments(stringFormat);

                    // explict parameter case
                    if (info.ExpectedStringFormatArgumentCount >= 0)
                    {
                        // TODO: due to a bug - https://github.com/dotnet/roslyn/issues/7346
                        //       vararg case is disabled.
                        //       we might check this only for C# since __arglist is not supported in VB
                        //
                        //       we need to implement proper support for __arglist once the bug is fixed.
                        if (invocation.TargetMethod.IsVararg)
                        {
                            // can't deal with this for now.
                            return;
                        }

                        if (info.ExpectedStringFormatArgumentCount != expectedStringFormatArgumentCount)
                        {
                            operationContext.ReportDiagnostic(operationContext.Operation.Syntax.CreateDiagnostic(Rule));
                        }

                        return;
                    }

                    // params case
                    IArgument paramsArgument = invocation.ArgumentsInParameterOrder[info.FormatStringIndex + 1];
                    if (paramsArgument.ArgumentKind != ArgumentKind.ParamArray)
                    {
                        // wrong format
                        return;
                    }

                    var arrayCreation = paramsArgument.Value as IArrayCreationExpression;
                    if (arrayCreation == null ||
                        !object.Equals(arrayCreation.ElementType, formatInfo.Object) ||
                        arrayCreation.DimensionSizes.Length != 1)
                    {
                        // wrong format
                        return;
                    }

                    // compiler generating object array for params case
                    IArrayInitializer intializer = arrayCreation.Initializer;
                    if (intializer == null)
                    {
                        // unsupported format
                        return;
                    }

                    // REVIEW: "ElementValues" is a bit confusing where I need to double dot those to get number of elements
                    int actualArgumentCount = intializer.ElementValues.Length;
                    if (actualArgumentCount != expectedStringFormatArgumentCount)
                    {
                        operationContext.ReportDiagnostic(operationContext.Operation.Syntax.CreateDiagnostic(Rule));
                    }
                }, OperationKind.InvocationExpression);
            });
        }
Exemple #8
0
        public override void Initialize(AnalysisContext analysisContext)
        {
            analysisContext.EnableConcurrentExecution();
            analysisContext.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);

            analysisContext.RegisterCompilationStartAction(compilationContext =>
            {
                var formatInfo = new StringFormatInfo(compilationContext.Compilation);

                compilationContext.RegisterOperationActionInternal(operationContext =>
                {
                    var invocation = (IInvocationExpression)operationContext.Operation;

                    StringFormatInfo.Info info = formatInfo.TryGet(invocation.TargetMethod);
                    if (info == null || invocation.ArgumentsInParameterOrder.Length <= info.FormatStringIndex)
                    {
                        // not a target method
                        return;
                    }

                    IArgument formatStringArgument = invocation.ArgumentsInParameterOrder[info.FormatStringIndex];
                    if (!object.Equals(formatStringArgument?.Value?.Type, formatInfo.String) ||
                        !(formatStringArgument?.Value?.ConstantValue.Value is string))
                    {
                        // wrong argument
                        return;
                    }

                    var stringFormat = (string)formatStringArgument.Value.ConstantValue.Value;
                    int expectedStringFormatArgumentCount = GetFormattingArguments(stringFormat);

                    // explict parameter case
                    if (info.ExpectedStringFormatArgumentCount >= 0)
                    {
                        // __arglist is not supported here
                        if (invocation.TargetMethod.IsVararg)
                        {
                            // can't deal with this for now.
                            return;
                        }

                        if (info.ExpectedStringFormatArgumentCount != expectedStringFormatArgumentCount)
                        {
                            operationContext.ReportDiagnostic(operationContext.Operation.Syntax.CreateDiagnostic(Rule));
                        }

                        return;
                    }

                    // params case
                    IArgument paramsArgument = invocation.ArgumentsInParameterOrder[info.FormatStringIndex + 1];
                    if (paramsArgument.ArgumentKind != ArgumentKind.ParamArray)
                    {
                        // wrong format
                        return;
                    }

                    var arrayCreation = paramsArgument.Value as IArrayCreationExpression;
                    if (arrayCreation == null ||
                        !object.Equals(arrayCreation.ElementType, formatInfo.Object) ||
                        arrayCreation.DimensionSizes.Length != 1)
                    {
                        // wrong format
                        return;
                    }

                    // compiler generating object array for params case
                    IArrayInitializer intializer = arrayCreation.Initializer;
                    if (intializer == null)
                    {
                        // unsupported format
                        return;
                    }

                    // REVIEW: "ElementValues" is a bit confusing where I need to double dot those to get number of elements
                    int actualArgumentCount = intializer.ElementValues.Length;
                    if (actualArgumentCount != expectedStringFormatArgumentCount)
                    {
                        operationContext.ReportDiagnostic(operationContext.Operation.Syntax.CreateDiagnostic(Rule));
                    }
                }, OperationKind.InvocationExpression);
            });
        }
 public virtual void visit(IArrayInitializer value)
 {
 }
Exemple #10
0
 static bool IsInvalidInitializer(IArrayInitializer initializer) => initializer.IsInvalid;
Exemple #11
0
 private ArrayCreationExpression(ITypeSymbol elementType, ImmutableArray <IOperation> dimensionSizes, IArrayInitializer initializer, SyntaxNode syntax, ITypeSymbol type, Optional <object> constantValue) :
     this(elementType, dimensionSizes, initializer, initializer.IsInvalid, syntax, type, constantValue)
 {
 }
        static bool IsInvalidInitializer(IArrayInitializer initializer)
        {
            switch (initializer.ArrayClass)
            {
                case ArrayInitializerKind.Dimension:
                    foreach (IArrayInitializer element in ((IDimensionArrayInitializer)initializer).ElementValues)
                    {
                        if (IsInvalidInitializer(element))
                        {
                            return true;
                        }
                    }

                    break;

                case ArrayInitializerKind.Expression:
                    return ((IExpressionArrayInitializer)initializer).ElementValue.IsInvalid;
            }

            return false;
        }
 /// <inheritdoc />
 public override IOperation VisitArrayInitializer(IArrayInitializer operation, object argument)
 {
     return(base.VisitArrayInitializer(operation, argument));
 }
Exemple #14
0
 public virtual void VisitArrayInitializer(IArrayInitializer operation)
 {
     DefaultVisit(operation);
 }
Exemple #15
0
 public override void VisitArrayInitializer(IArrayInitializer operation)
 {
     base.VisitArrayInitializer(operation);
 }
Exemple #16
0
 private void CreateArrayGlobalVariable(ILGenerator il, FieldBuilder fb, TypeInfo ti, IArrayInitializer InitalValue, ITypeNode arr_type)
 {
     int rank = 1;
     if (NETGeneratorTools.IsBoundedArray(ti))
         NETGeneratorTools.CreateBoundedArray(il, fb, ti);
     else
     {
         rank = get_rank(arr_type);
         if (rank == 1)
             CreateUnsizedArray(il, fb, helper.GetTypeReference(arr_type.element_type), InitalValue.ElementValues.Length);
         else
             CreateNDimUnsizedArray(il, fb, arr_type, helper.GetTypeReference(arr_type.element_type), rank, get_sizes(InitalValue, rank));
     }
     if (InitalValue != null)
     {
         LocalBuilder lb = null;
         //				if (save_debug_info && comp_opt.GenerateDebugInfoForInitalValue)
         //            	{
         //            		if (InitalValue.Location != null)
         //            		MarkSequencePoint(InitalValue.Location);
         //            	}
         if (NETGeneratorTools.IsBoundedArray(ti))
         {
             lb = il.DeclareLocal(ti.arr_fld.FieldType);
             il.Emit(OpCodes.Ldsfld, fb);
             il.Emit(OpCodes.Ldfld, ti.arr_fld);
         }
         else
         {
             lb = il.DeclareLocal(ti.tp);
             il.Emit(OpCodes.Ldsfld, fb);
         }
         il.Emit(OpCodes.Stloc, lb);
         if (rank == 1)
             GenerateArrayInitCode(il, lb, InitalValue, arr_type);
         else
             GenerateNDimArrayInitCode(il, lb, InitalValue, arr_type, rank);
     }
 }
Exemple #17
0
 private static bool IsInvalidInitializer(IArrayInitializer initializer) => initializer.IsInvalid;
Exemple #18
0
 private int[] get_sizes(IArrayInitializer InitalValue, int rank)
 {
     List<int> sizes = new List<int>();
     sizes.Add(InitalValue.ElementValues.Length);
     if (rank > 1)
         sizes.AddRange(get_sizes(InitalValue.ElementValues[0] as IArrayInitializer, rank - 1));
     return sizes.ToArray();
 }
Exemple #19
0
        private void CreateArrayForClassField(ILGenerator il, FieldBuilder fb, TypeInfo ti, IArrayInitializer InitalValue, ITypeNode ArrayType)
        {
            int rank = 1;
            il.Emit(OpCodes.Ldarg_0);
            if (NETGeneratorTools.IsBoundedArray(ti))
                NETGeneratorTools.CreateBoundedArray(il, fb, ti);
            else
            {
                rank = get_rank(ArrayType);
                if (rank == 1)
                    CreateUnsizedArray(il, fb, helper.GetTypeReference(InitalValue.ElementType), InitalValue.ElementValues.Length);
                else
                    CreateNDimUnsizedArray(il, fb, ArrayType, helper.GetTypeReference(InitalValue.ElementType), rank, get_sizes(InitalValue, rank));

            }
            if (InitalValue != null)
            {
                LocalBuilder lb = null;
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldfld, fb);
                if (NETGeneratorTools.IsBoundedArray(ti))
                {
                    lb = il.DeclareLocal(ti.arr_fld.FieldType);
                    il.Emit(OpCodes.Ldfld, ti.arr_fld);
                }
                else
                {
                    lb = il.DeclareLocal(ti.tp);
                }
                il.Emit(OpCodes.Stloc, lb);
                if (rank == 1)
                    GenerateArrayInitCode(il, lb, InitalValue, ArrayType);
                else
                    GenerateNDimArrayInitCode(il, lb, InitalValue, ArrayType, rank);
            }
        }
Exemple #20
0
 public override void visit(IArrayInitializer value)
 {
     TypeInfo ti = helper.GetTypeReference(value.type);
     LocalBuilder lb = il.DeclareLocal(ti.tp);
     CreateArrayLocalVariable(il, lb, ti, value, value.type);
     il.Emit(OpCodes.Ldloc, lb);
 }
Exemple #21
0
 public override void VisitArrayInitializer(IArrayInitializer operation)
 {
     VisitArray(operation.ElementValues);
 }
Exemple #22
0
 public void visit(IArrayInitializer value)
 {
 }
Exemple #23
0
 private void EmitArrayIndex(ILGenerator il, MethodInfo set_meth, LocalBuilder lb, IArrayInitializer InitalValue, int rank, int act_rank, List<int> indices)
 {
     IExpressionNode[] ElementValues = InitalValue.ElementValues;
     for (int i = 0; i < ElementValues.Length; i++)
     {
         if (indices.Count < act_rank)
             indices.Add(i);
         else
             indices[indices.Count - rank] = i;
         if (rank > 1)
             EmitArrayIndex(il, set_meth, lb, ElementValues[i] as IArrayInitializer, rank - 1, act_rank, indices);
         else
         {
             if (indices.Count < act_rank)
                 indices.Add(i);
             else
                 indices[indices.Count - rank] = i;
             il.Emit(OpCodes.Ldloc, lb);
             for (int j = 0; j < indices.Count; j++)
                 il.Emit(OpCodes.Ldc_I4, indices[j]);
             ILGenerator tmp_il = this.il;
             this.il = il;
             ElementValues[i].visit(this);
             EmitBox(ElementValues[i], lb.LocalType.GetElementType());
             this.il = tmp_il;
             il.Emit(OpCodes.Call, set_meth);
         }
     }
 }
Exemple #24
0
 public override IOperation VisitArrayInitializer(IArrayInitializer operation, object argument)
 {
     return(new ArrayInitializer(VisitArray(operation.ElementValues), ((Operation)operation).SemanticModel, operation.Syntax, operation.Type, operation.ConstantValue, operation.IsImplicit));
 }
 public override void VisitArrayInitializer(IArrayInitializer operation)
 {
     base.VisitArrayInitializer(operation);
 }
Exemple #26
0
 private void GenerateNDimArrayInitCode(ILGenerator il, LocalBuilder lb, IArrayInitializer InitalValue, ITypeNode ArrayType, int rank)
 {
     IExpressionNode[] ElementValues = InitalValue.ElementValues;
     Type elem_type = helper.GetTypeReference(ArrayType.element_type).tp;
     MethodInfo set_meth = null;
     if (ArrayType is ICompiledTypeNode)
         set_meth = lb.LocalType.GetMethod("Set");
     else
     {
         List<Type> lst = new List<Type>();
         for (int i = 0; i < rank; i++)
             lst.Add(TypeFactory.Int32Type);
         lst.Add(elem_type);
         set_meth = mb.GetArrayMethod(lb.LocalType, "Set", CallingConventions.HasThis, TypeFactory.VoidType, lst.ToArray());
     }
     List<int> indices = new List<int>();
     for (int i = 0; i < ElementValues.Length; i++)
     {
         if (i == 0)
             indices.Add(i);
         else
             indices[indices.Count - rank] = i;
         EmitArrayIndex(il, set_meth, lb, ElementValues[i] as IArrayInitializer, rank - 1, rank, indices);
     }
 }
 public virtual void VisitArrayInitializer(IArrayInitializer operation)
 {
     DefaultVisit(operation);
 }
Exemple #28
0
        private void GenerateArrayInitCode(ILGenerator il, LocalBuilder lb, IArrayInitializer InitalValue, ITypeNode ArrayType)
        {
            IExpressionNode[] ElementValues = InitalValue.ElementValues;
            if (ElementValues[0] is IArrayInitializer)
            {
                bool is_unsized_array;
                Type FieldType, ArrType;
                int rank = get_rank(ElementValues[0].type);
                TypeInfo ti = helper.GetTypeReference(ElementValues[0].type);
                if (NETGeneratorTools.IsBoundedArray(ti))
                {
                    is_unsized_array = false;
                    ArrType = ti.tp;
                    FieldType = ti.arr_fld.FieldType;
                }
                else
                {
                    is_unsized_array = true;
                    ArrType = helper.GetTypeReference(ElementValues[0].type).tp;
                    FieldType = ArrType;
                }
                LocalBuilder llb = il.DeclareLocal(FieldType);
                for (int i = 0; i < ElementValues.Length; i++)
                {
                    il.Emit(OpCodes.Ldloc, lb);
                    PushIntConst(il, i);
                    if (!is_unsized_array)
                    {
                        il.Emit(OpCodes.Ldelem, ArrType);
                        il.Emit(OpCodes.Ldfld, ti.arr_fld);
                    }
                    else
                    {
                        //il.Emit(OpCodes.Ldelema, ArrType);
                        if (rank > 1)
                            CreateNDimUnsizedArray(il, (ElementValues[i] as IArrayInitializer).type, helper.GetTypeReference((ElementValues[i] as IArrayInitializer).type.element_type), rank, get_sizes(ElementValues[0] as IArrayInitializer, rank), lb.LocalType.GetElementType());
                        else
                            CreateUnsizedArray(il, helper.GetTypeReference((ElementValues[i] as IArrayInitializer).type.element_type), (ElementValues[0] as IArrayInitializer).ElementValues.Length, lb.LocalType.GetElementType());
                        il.Emit(OpCodes.Stelem, ArrType);
                        il.Emit(OpCodes.Ldloc, lb);
                        PushIntConst(il, i);
                        il.Emit(OpCodes.Ldelem, ArrType);
                        //il.Emit(OpCodes.Ldelem_Ref);
                    }
                    il.Emit(OpCodes.Stloc, llb);
                    if (rank > 1)
                        GenerateNDimArrayInitCode(il, llb, ElementValues[i] as IArrayInitializer, ElementValues[i].type, rank);
                    else
                        GenerateArrayInitCode(il, llb, ElementValues[i] as IArrayInitializer, ArrayType);
                }
            }
            else
                if (ElementValues[0] is IRecordConstantNode || ElementValues[0] is IRecordInitializer)
                {
                    TypeInfo ti = helper.GetTypeReference(ElementValues[0].type);
                    LocalBuilder llb = il.DeclareLocal(ti.tp.MakePointerType());
                    for (int i = 0; i < ElementValues.Length; i++)
                    {
                        il.Emit(OpCodes.Ldloc, lb);
                        PushIntConst(il, i);
                        il.Emit(OpCodes.Ldelema, ti.tp);
                        il.Emit(OpCodes.Stloc, llb);
                        if (ElementValues[0] is IRecordConstantNode)
                            GenerateRecordInitCode(il, llb, ElementValues[i] as IRecordConstantNode);
                        else GenerateRecordInitCode(il, llb, ElementValues[i] as IRecordInitializer, true);
                    }
                }
                else
                    for (int i = 0; i < ElementValues.Length; i++)
                    {
                        il.Emit(OpCodes.Ldloc, lb);
                        PushIntConst(il, i);
                        ILGenerator ilb = this.il;
                        TypeInfo ti = helper.GetTypeReference(ElementValues[i].type);

                        if (ti != null && ti.is_set)
                        {
                            this.il = il;
                            IConstantNode cn1 = null;
                            IConstantNode cn2 = null;
                            if (ArrayType != null && ArrayType.element_type.element_type is ICommonTypeNode)
                            {
                                cn1 = (ArrayType.element_type.element_type as ICommonTypeNode).lower_value;
                                cn2 = (ArrayType.element_type.element_type as ICommonTypeNode).upper_value;
                            }
                            if (cn1 != null && cn2 != null)
                            {
                                cn1.visit(this);
                                il.Emit(OpCodes.Box, helper.GetTypeReference(cn1.type).tp);
                                cn2.visit(this);
                                il.Emit(OpCodes.Box, helper.GetTypeReference(cn2.type).tp);
                            }
                            else
                            {
                                il.Emit(OpCodes.Ldnull);
                                il.Emit(OpCodes.Ldnull);
                            }
                            il.Emit(OpCodes.Newobj, ti.def_cnstr);
                            il.Emit(OpCodes.Stelem_Ref);
                            il.Emit(OpCodes.Ldloc, lb);
                            PushIntConst(il, i);
                            this.il = ilb;
                            //il.Emit(OpCodes.Ldelem_Ref);
                        }
                        if (ti != null && ti.tp.IsValueType && !TypeFactory.IsStandType(ti.tp) && !ti.tp.IsEnum)
                            il.Emit(OpCodes.Ldelema, ti.tp);
                        else
                            if (ti != null && ti.assign_meth != null)
                                il.Emit(OpCodes.Ldelem_Ref);
                        this.il = il;
                        ElementValues[i].visit(this);
                        if (ti != null && ti.assign_meth != null)
                        {
                            il.Emit(OpCodes.Call, ti.assign_meth);
                            this.il = ilb;
                            continue;
                        }
                        bool box = EmitBox(ElementValues[i], lb.LocalType.GetElementType());
                        this.il = ilb;
                        if (ti != null && !box)
                            NETGeneratorTools.PushStelem(il, ti.tp);
                        else
                            il.Emit(OpCodes.Stelem_Ref);
                    }
        }
 /// <inheritdoc />
 public override Expression VisitArrayInitializer(IArrayInitializer operation, LocalBinder argument)
 {
     return(base.VisitArrayInitializer(operation, argument));
 }
Exemple #30
0
		public void visit(IArrayInitializer value)
		{
            throw new System.NotSupportedException(value.GetType().ToString());
		}