public void SetUp() { arrayNodes = new ExprArrayNode[4]; arrayNodes[0] = new ExprArrayNode(); // no coercion array arrayNodes[1] = new ExprArrayNode(); arrayNodes[1].AddChildNode(new SupportExprNode(2)); arrayNodes[1].AddChildNode(new SupportExprNode(3)); // coercion arrayNodes[2] = new ExprArrayNode(); arrayNodes[2].AddChildNode(new SupportExprNode(1.5D)); arrayNodes[2].AddChildNode(new SupportExprNode(1)); // mixed types arrayNodes[3] = new ExprArrayNode(); arrayNodes[3].AddChildNode(new SupportExprNode("a")); arrayNodes[3].AddChildNode(new SupportExprNode(1)); for (var i = 0; i < arrayNodes.Length; i++) { arrayNodes[i].Validate(SupportExprValidationContextFactory.MakeEmpty(container)); } }
public ExprArrayNodeForge( ExprArrayNode parent, Type arrayReturnType, object[] constantResult) { _constantResult = constantResult; Parent = parent; ArrayReturnType = arrayReturnType; IsMustCoerce = false; Coercer = null; }
public ExprArrayNodeForge( ExprArrayNode parent, Type arrayReturnType, bool mustCoerce, Coercer coercer, object constantResult) { _constantResult = (Array) constantResult; Parent = parent; ArrayReturnType = arrayReturnType; IsMustCoerce = mustCoerce; Coercer = coercer; }
public override ExprNode Validate(ExprValidationContext validationContext) { // Resolve target class Type targetClass = null; if (_numArrayDimensions != 0) { targetClass = TypeHelper.GetPrimitiveTypeForName(_classIdent); } if (targetClass == null) { try { targetClass = validationContext.ImportService .ResolveClass(_classIdent, false, validationContext.ClassProvidedExtension); } catch (ImportException) { throw new ExprValidationException("Failed to resolve new-operator class name '" + _classIdent + "'"); } } // handle non-array if (_numArrayDimensions == 0) { InstanceManufacturerFactory manufacturerFactory = InstanceManufacturerFactoryFactory.GetManufacturer( targetClass, validationContext.ImportService, this.ChildNodes); _forge = new ExprNewInstanceNodeNonArrayForge(this, targetClass, manufacturerFactory); return null; } // determine array initialized or not var targetClassArray = TypeHelper.GetArrayType(targetClass, _numArrayDimensions); if (ChildNodes.Length == 1 && ChildNodes[0] is ExprArrayNode) { _arrayInitializedByExpr = true; } else { foreach (ExprNode child in ChildNodes) { var evalType = child.Forge.EvaluationType; if (!TypeHelper.IsInt32(evalType)) { string message = "New-keyword with an array-type result requires an Integer-typed dimension but received type '" + evalType.CleanName() + "'"; throw new ExprValidationException(message); } } } // handle array initialized by dimension only if (!_arrayInitializedByExpr) { _forge = new ExprNewInstanceNodeArrayForge(this, targetClass, targetClassArray); return null; } // handle array initialized by array expression if (_numArrayDimensions < 1 || _numArrayDimensions > 2) { throw new IllegalStateException("Num-array-dimensions unexpected at " + _numArrayDimensions); } ExprArrayNode arrayNode = (ExprArrayNode) ChildNodes[0]; // handle 2-dimensional array validation if (_numArrayDimensions == 2) { foreach (ExprNode inner in arrayNode.ChildNodes) { if (!(inner is ExprArrayNode)) { throw new ExprValidationException( "Two-dimensional array element does not allow element expression '" + ExprNodeUtilityPrint.ToExpressionStringMinPrecedenceSafe(inner) + "'"); } ExprArrayNode innerArray = (ExprArrayNode) inner; innerArray.OptionalRequiredType = targetClass; innerArray.Validate(validationContext); } arrayNode.OptionalRequiredType = targetClassArray.GetElementType(); } else { arrayNode.OptionalRequiredType = targetClass; } arrayNode.Validate(validationContext); _forge = new ExprNewInstanceNodeArrayForge(this, targetClass, targetClassArray); return null; }