public void FindPropertiesWithAttributeOfType()
{
// Arrange
// Act
// Assert
NullType.FindPropertiesWithAttributeOfType <ReflectionTestAttribute>(false).Should().BeEmpty();
NullType.FindPropertiesWithAttributeOfType(typeof(ReflectionTestAttribute), false).Should().BeEmpty();
NullType.FindPropertiesWithAttributeOfType <ReflectionTestAttribute>(false, BindingFlags.Instance | BindingFlags.NonPublic)
.Should()
.BeEmpty();
NullType.FindPropertiesWithAttributeOfType(typeof(ReflectionTestAttribute), false, BindingFlags.Instance | BindingFlags.NonPublic)
.Should()
.BeEmpty();
TestType.FindPropertiesWithAttributeOfType <ReflectionTestAttribute>(false).Should().HaveCount(3);
TestType.FindPropertiesWithAttributeOfType(typeof(ReflectionTestAttribute), false).Should().HaveCount(3);
TestType.FindPropertiesWithAttributeOfType <ReflectionTestAttribute>(false, BindingFlags.Instance | BindingFlags.NonPublic)
.Should()
.HaveCount(3);
TestType.FindPropertiesWithAttributeOfType(typeof(ReflectionTestAttribute), false, BindingFlags.Instance | BindingFlags.NonPublic)
.Should()
.HaveCount(3);
}
public TypeManager()
{
_predefTypes = null; // Initialized via the Init call.
_BSymmgr = null; // Initialized via the Init call.
_typeFactory = new TypeFactory();
_typeTable = new TypeTable();
// special types with their own symbol kind.
_errorType = _typeFactory.CreateError(null, null, null, null, null);
_voidType = _typeFactory.CreateVoid();
_nullType = _typeFactory.CreateNull();
_typeUnit = _typeFactory.CreateUnit();
_typeAnonMeth = _typeFactory.CreateAnonMethod();
_typeMethGrp = _typeFactory.CreateMethodGroup();
_argListType = _typeFactory.CreateArgList();
InitType(_errorType);
_errorType.SetErrors(true);
InitType(_voidType);
InitType(_nullType);
InitType(_typeUnit);
InitType(_typeAnonMeth);
InitType(_typeMethGrp);
_stvcMethod = new StdTypeVarColl();
_stvcClass = new StdTypeVarColl();
}
/// <summary>
/// 处理可空类型
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static Type GetNicePropertyInfo(Type type)
{
NullType nullType = new NullType();
if (type.ToString() == "System.Nullable`1[System.Int32]")
{
type = nullType.NullInt.GetType();
}
if (type.ToString() == "System.Nullable`1[System.Decimal]")
{
type = nullType.NullDecimal.GetType();
}
if (type.ToString() == "System.Nullable`1[System.Double]")
{
type = nullType.NullDoublel.GetType();
}
if (type.ToString() == "System.Nullable`1[System.Long]")
{
type = nullType.NullLong.GetType();
}
if (type.ToString() == "System.Nullable`1[System.DateTime]")
{
type = nullType.NullDateTime.GetType();
}
return(type);
}
/// <summary>
/// First operand is NullType Expression, the method return a type expressión
/// if the second operand is promotable to StringType and the operator is PLUS
/// </summary>
/// <param name="firstOperand">a NullType TypeExpression</param>
/// <returns>return a type expressión if the second operand is promotable to StringType
/// and the operator is PLUS. False otherwise.</returns>
public override object Exec(NullType firstOperand, object arg)
{
if (this.binaryOperator.Equals(ArithmeticOperator.Plus) && (bool)this.secondOperand.AcceptOperation(new EquivalentOperation(StringType.Instance), arg))
{
return(StringType.Instance);
}
if (showErrorMessage)
{
ErrorManager.Instance.NotifyError(new TypePromotionError(this.secondOperand.FullName, firstOperand.FullName, this.binaryOperator.ToString(), this.location));
}
return(null);
}
public override bool check(CodeContext context)
{
if (is_checked)
{
return(!error);
}
is_checked = true;
value_type = new NullType(source_reference);
return(!error);
}
public void IsSubclassOf()
{
// Arrange
// Act
// Assert
NullType.IsSubclassOf <object>().Should().BeFalse();
TestType.IsSubclassOf <object>().Should().BeTrue();
typeof(ArgumentNullException).IsSubclassOf <ArgumentException>().Should().BeTrue();
typeof(Exception).IsSubclassOf <ArgumentException>().Should().BeFalse();
}
public override object Exec(NullType firstOperand, object arg)
{
// * Built-in types: no promotion, except string
if (this.secondOperand is BoolType || this.secondOperand is CharType || this.secondOperand is DoubleType || this.secondOperand is IntType || this.secondOperand is VoidType)
{
return(-1);
}
// * BCL Value Types (structs): No promotion
BCLClassType bclClass = TypeExpression.As <BCLClassType>(this.secondOperand);
if (bclClass != null)
{
if (bclClass.TypeInfo.IsValueType)
{
return(-1);
}
// * Correct promotion to classes that are not value types
return(0);
}
// * WriteType variable
TypeVariable typeVariable = this.secondOperand as TypeVariable;
if (typeVariable != null)
{
if (typeVariable.Substitution != null)
{
// * If the variable is bounded, the promotion is the one of its substitution
return(firstOperand.AcceptOperation(new PromotionLevelOperation(typeVariable.EquivalenceClass.Substitution), arg));
}
// * A free variable is complete promotion
return(0);
}
// * Union type
UnionType unionType = TypeExpression.As <UnionType>(this.secondOperand);
if (unionType != null)
{
return(unionType.SuperType(firstOperand));
}
// * Field type and bounded type variable
FieldType fieldType = TypeExpression.As <FieldType>(this.secondOperand);
if (fieldType != null)
{
return(firstOperand.AcceptOperation(new PromotionLevelOperation(fieldType.FieldTypeExpression), arg));
}
// * Correct Promotion
return(0);
}
public static Expression CreateParenthesized(Context cx, VarPatternSyntax varPattern, ParenthesizedVariableDesignationSyntax designation, IExpressionParentEntity parent, int child)
{
var type = NullType.Create(cx); // Should ideally be a corresponding tuple type
var tuple = new Expression(new ExpressionInfo(cx, type, cx.Create(varPattern.GetLocation()), ExprKind.TUPLE, parent, child, false, null));
cx.Try(null, null, () =>
{
var child0 = 0;
foreach (var variable in designation.Variables)
{
switch (variable)
{
case ParenthesizedVariableDesignationSyntax paren:
CreateParenthesized(cx, varPattern, paren, tuple, child0++);
break;
case SingleVariableDesignationSyntax single:
if (cx.GetModel(variable).GetDeclaredSymbol(single) is ILocalSymbol local)
{
var decl = Create(cx, variable, Entities.Type.Create(cx, local.GetAnnotatedType()), true, tuple, child0++);
var id = single.Identifier;
var location = cx.Create(id.GetLocation());
LocalVariable.Create(cx, local, decl, true, location);
}
else
{
throw new InternalError(single, "Failed to access local variable");
}
break;
case DiscardDesignationSyntax discard:
new Discard(cx, discard, tuple, child0++);
break;
default:
throw new InternalError(variable, "Unhandled designation type");
}
}
});
return(tuple);
}
static VariableDeclaration CreateSingle(Context cx, DeclarationExpressionSyntax node, SingleVariableDesignationSyntax designation, IExpressionParentEntity parent, int child)
{
bool isVar = node.Type.IsVar;
var variableSymbol = cx.GetModel(designation).GetDeclaredSymbol(designation) as ILocalSymbol;
if (variableSymbol == null)
{
cx.ModelError(node, "Failed to determine local variable");
return(Create(cx, node, NullType.Create(cx), isVar, parent, child));
}
var type = Entities.Type.Create(cx, variableSymbol.GetAnnotatedType());
var location = cx.Create(designation.GetLocation());
var ret = Create(cx, designation, type, isVar, parent, child);
cx.Try(null, null, () => LocalVariable.Create(cx, variableSymbol, ret, isVar, location));
return(ret);
}
private static Expression Create(Context cx, DeclarationExpressionSyntax node, VariableDesignationSyntax designation, IExpressionParentEntity parent, int child)
{
switch (designation)
{
case SingleVariableDesignationSyntax single:
return(CreateSingle(cx, node, single, parent, child));
case ParenthesizedVariableDesignationSyntax paren:
return(CreateParenthesized(cx, node, paren, parent, child));
case DiscardDesignationSyntax discard:
var ti = cx.GetType(discard);
var type = Entities.Type.Create(cx, ti);
return(Create(cx, node, type, parent, child));
default:
cx.ModelError(node, "Failed to determine designation type");
return(Create(cx, node, NullType.Create(cx), parent, child));
}
}
public void FindPropertiesOfType()
{
// Arrange
// Act
// Assert
NullType.FindPropertiesOfType <string>().Should().BeEmpty();
NullType.FindPropertiesOfType(typeof(string)).Should().BeEmpty();
NullType.FindPropertiesOfType <string>(BindingFlags.NonPublic).Should().BeEmpty();
NullType.FindPropertiesOfType(typeof(string), BindingFlags.NonPublic).Should().BeEmpty();
TestType.FindPropertiesOfType <string>().Should().HaveCount(2);
TestType.FindPropertiesOfType(typeof(string)).Should().HaveCount(2);
TestType.FindPropertiesOfType <string>(BindingFlags.Instance | BindingFlags.NonPublic).Should().HaveCount(3);
TestType.FindPropertiesOfType(typeof(string), BindingFlags.Instance | BindingFlags.NonPublic).Should().HaveCount(3);
TestType.FindPropertiesOfType <Gender>().Should().HaveCount(1);
TestType.FindPropertiesOfType(typeof(Gender)).Should().HaveCount(1);
TestType.FindPropertiesOfType <Gender>(BindingFlags.Instance | BindingFlags.NonPublic).Should().HaveCount(0);
TestType.FindPropertiesOfType(typeof(Gender), BindingFlags.Instance | BindingFlags.NonPublic).Should().HaveCount(0);
}
public virtual TReturn Visit(NullType node, TParam param) => throw new NotImplementedException();
public void Read(TProtocol iprot)
{
TField field;
iprot.ReadStructBegin();
while (true)
{
field = iprot.ReadFieldBegin();
if (field.Type == TType.Stop)
{
break;
}
switch (field.ID)
{
case 1:
if (field.Type == TType.I32)
{
this.nVal = (NullType)iprot.ReadI32();
this.__isset.nVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 2:
if (field.Type == TType.Bool)
{
this.bVal = iprot.ReadBool();
this.__isset.bVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 3:
if (field.Type == TType.I64)
{
this.iVal = iprot.ReadI64();
this.__isset.iVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 4:
if (field.Type == TType.Double)
{
this.fVal = iprot.ReadDouble();
this.__isset.fVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 5:
if (field.Type == TType.String)
{
this.sVal = iprot.ReadBinary();
this.__isset.sVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 6:
if (field.Type == TType.Struct)
{
this.dVal = new Date();
this.dVal.Read(iprot);
this.__isset.dVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 7:
if (field.Type == TType.Struct)
{
this.tVal = new Time();
this.tVal.Read(iprot);
this.__isset.tVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 8:
if (field.Type == TType.Struct)
{
this.dtVal = new DateTime();
this.dtVal.Read(iprot);
this.__isset.dtVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 9:
if (field.Type == TType.Struct)
{
this.vVal = new Vertex();
this.vVal.Read(iprot);
this.__isset.vVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 10:
if (field.Type == TType.Struct)
{
this.eVal = new Edge();
this.eVal.Read(iprot);
this.__isset.eVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 11:
if (field.Type == TType.Struct)
{
this.pVal = new Path();
this.pVal.Read(iprot);
this.__isset.pVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 12:
if (field.Type == TType.Struct)
{
this.lVal = new List();
this.lVal.Read(iprot);
this.__isset.lVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 13:
if (field.Type == TType.Struct)
{
this.mVal = new Map();
this.mVal.Read(iprot);
this.__isset.mVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 14:
if (field.Type == TType.Struct)
{
this.uVal = new Set();
this.uVal.Read(iprot);
this.__isset.uVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
case 15:
if (field.Type == TType.Struct)
{
this.gVal = new DataSet();
this.gVal.Read(iprot);
this.__isset.gVal = true;
}
else
{
TProtocolUtil.Skip(iprot, field.Type);
}
break;
default:
TProtocolUtil.Skip(iprot, field.Type);
break;
}
iprot.ReadFieldEnd();
}
iprot.ReadStructEnd();
}
public virtual TReturn Visit(NullType node, TParam param)
{
return(DefaultReturn);
}
public void WithNullSourceType_ThrowsArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() =>
NullType.GetMethod(Flags, _methodName, _genericTypes, _parameterTypes));
}
public void WithNullType_ThrowsArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() => NullType.IsCollection());
}
public void WithNullType_ThrowsArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() => NullType.IsIEnumerable());
}
public void WithNullType_ThrowsArgumentNullException()
{
Assert.Throws <ArgumentNullException>(() => NullType.GetDefault());
}
public void NullHandler(NullType n) => Assert.True(false);
ArrayInitializer(ExpressionNodeInfo info) : base(info.SetType(NullType.Create(info.Context)).SetKind(ExprKind.ARRAY_INIT))
{
}
public GenericValueType(object value)
{
if (value == null)
{
Item = new NullType();
ItemElementName = ItemChoiceType.Null;
}
else
{
Type valueType = value.GetType();
if (valueType == typeof(byte[]))
{
Item = value;
ItemElementName = ItemChoiceType.Base64Binary;
}
else if (valueType == typeof(bool))
{
Item = value;
ItemElementName = ItemChoiceType.Boolean;
}
else if (valueType == typeof(sbyte))
{
Item = value;
ItemElementName = ItemChoiceType.Byte;
}
else if (valueType == typeof(ushort))
{
Item = value;
ItemElementName = ItemChoiceType.Character;
}
else if (valueType == typeof(DateTime))
{
Item = value;
ItemElementName = ItemChoiceType.DateTime;
}
else if (valueType == typeof(float))
{
Item = value;
ItemElementName = ItemChoiceType.Float;
}
else if (valueType == typeof(decimal))
{
Item = value;
ItemElementName = ItemChoiceType.Decimal;
}
else if (valueType == typeof(double))
{
Item = value;
ItemElementName = ItemChoiceType.Double;
}
else if (valueType == typeof(int))
{
Item = value;
ItemElementName = ItemChoiceType.Int;
}
else if (valueType == typeof(long))
{
Item = value;
ItemElementName = ItemChoiceType.Long;
}
else if (valueType == typeof(short))
{
Item = value;
ItemElementName = ItemChoiceType.Short;
}
else if (valueType == typeof(string))
{
Item = value;
ItemElementName = ItemChoiceType.String;
}
else if (valueType == typeof(Uri))
{
Item = value.ToString();
ItemElementName = ItemChoiceType.URI;
}
else if (valueType == typeof(Guid))
{
Item = value.ToString();
ItemElementName = ItemChoiceType.UUID;
}
else if (valueType == typeof(TimeSpan))
{
Item = value.ToString();
ItemElementName = ItemChoiceType.Duration;
}
else if (valueType.GetInterface("IDictionary`2") != null)
{
Item = new TypedMapType((IDictionary)value);
ItemElementName = ItemChoiceType.TypedMap;
}
else if (typeof(IDictionary).IsAssignableFrom(valueType))
{
Item = new MapType((IDictionary)value);
ItemElementName = ItemChoiceType.Map;
}
else if (valueType.GetInterface("ICollection`1") != null)
{
Item = new TypedMultipleValueType((ICollection)value);
ItemElementName = ItemChoiceType.TypedList;
}
else if (typeof(ICollection).IsAssignableFrom(valueType))
{
Item = new MultipleValueType((ICollection)value);
ItemElementName = ItemChoiceType.List;
}
else if (valueType == typeof(XmlQualifiedName))
{
Item = value;
ItemElementName = ItemChoiceType.QName;
}
else if (valueType == typeof(ObjectName))
{
Item = ObjectNameSelector.CreateEndpointAddress((ObjectName)value);
ItemElementName = ItemChoiceType.EndpointReference;
}
else if (valueType == typeof(RoleInfo))
{
Item = new ManagedResourceRoleInfo((RoleInfo)value);
ItemElementName = ItemChoiceType.ManagedResourceRoleInfo;
}
else if (valueType == typeof(RoleResult))
{
Item = new ManagedResourceRoleResult((RoleResult)value);
ItemElementName = ItemChoiceType.ManagedResourceRoleResult;
}
else if (typeof(ITabularData).IsAssignableFrom(valueType))
{
Item = new TabularDataValueType((ITabularData)value);
ItemElementName = ItemChoiceType.TabularDataValue;
}
else if (typeof(ICompositeData).IsAssignableFrom(valueType))
{
Item = new CompositeDataValueType((ICompositeData)value);
ItemElementName = ItemChoiceType.CompositeDataValue;
}
else if (typeof(OpenType).IsAssignableFrom(valueType))
{
Item = OpenDataType_Type.Serialize(value, out itemElementNameField);
}
else
{
throw new NotSupportedException("Not supported type in serialization: " + valueType);
}
}
}
public void NullCompareInIfBlock()
{
const string block = "#if( $str == null )GOOO#{else}STOPPPPP#{end}";
var s = State();
s["str"] = new NullType();
var result1 = Template.ImmediateApply(s, block);
Assert.False(result1.Errors.ContainsError());
Assert.False(result1.Errors.ContainsWarning());
Assert.AreEqual("GOOO", result1.Output);
var result2 = Template.CompileAndRun("test", block, s);
Assert.False(result2.Errors.ContainsError());
Assert.False(result2.Errors.ContainsWarning());
Assert.AreEqual("GOOO", result2.Output);
}
/// <summary>
/// It performs a an assigment operation with a NullType as left operand. The operaton can only be done if op attribute is set to Attribute.Assign.
/// </summary>
/// <param name="leftOperand">A NullType as left Operarand</param>
/// <returns>The right operand, if the op == AssignmentOperator.Assign. raises and error in other case.</returns>
public override object Exec(NullType leftOperand, object arg)
{
return(op == AssignmentOperator.Assign ? this.rightOperand : ReportError(leftOperand));
}
public void GetMemberValues(string prefix, Object properties, JSONPROXY dict,
List<Object> exceptFor)
{
if (properties == null)
{
return;
}
var o0 = properties;
bool neededDecode;
if (o0 is IJSONPROXY)
{
foreach (var kv in (IJSONPROXY) o0)
{
string joinedName = JoinedName(prefix, kv.Key);
AddValue(joinedName, DecodeValue(joinedName + "_", kv.Value, out neededDecode), dict);
}
return;
}
else if (o0 is IDictionary)
{
foreach (DictionaryEntry kv in (IDictionary) o0)
{
string joinedName = JoinedName(prefix, "" + kv.Key);
AddValue(joinedName, kv.Value, dict);
}
return;
}
Type t = properties.GetType();
KeyValuePair<List<PropertyInfo>, List<FieldInfo>> vvv = GetPropsForTypes(t);
List<string> lowerProps = new List<string>();
BindingFlags flags = BindingFlags.Instance | BindingFlags.Public; //BindingFlags.NonPublic
foreach (PropertyInfo o in vvv.Key)
{
try
{
Type pt = o.PropertyType;
if (!IsOKType(pt)) continue;
var v = o.GetValue(properties, null);
if (v == null)
{
v = new NullType(properties, o);
}
pt = v.GetType();
if (!IsOKType(pt)) continue;
if (exceptFor.Contains(v)) continue;
AddValue(JoinedName(prefix, o.Name), v, dict);
}
catch (Exception e)
{
DLRConsole.DebugWriteLine("" + e);
}
}
foreach (FieldInfo o in vvv.Value)
{
try
{
Type pt = o.FieldType;
if (!IsOKType(pt)) continue;
var v = o.GetValue(properties);
if (v == null)
{
v = new NullType(properties, o);
}
if (!IsOKType(pt)) continue;
if (exceptFor.Contains(v)) continue;
AddValue(JoinedName(prefix, o.Name), v, dict);
}
catch (Exception e)
{
DLRConsole.DebugWriteLine("" + e);
}
}
}
public GenericValueType(object value)
{
if (value == null)
{
Item = new NullType();
ItemElementName = ItemChoiceType.Null;
}
else
{
Type valueType = value.GetType();
if (valueType == typeof(byte[]))
{
Item = value;
ItemElementName = ItemChoiceType.Base64Binary;
}
else if (valueType == typeof(bool))
{
Item = value;
ItemElementName = ItemChoiceType.Boolean;
}
else if (valueType == typeof(sbyte))
{
Item = value;
ItemElementName = ItemChoiceType.Byte;
}
else if (valueType == typeof(ushort))
{
Item = value;
ItemElementName = ItemChoiceType.Character;
}
else if (valueType == typeof(DateTime))
{
Item = value;
ItemElementName = ItemChoiceType.DateTime;
}
else if (valueType == typeof(float))
{
Item = value;
ItemElementName = ItemChoiceType.Float;
}
else if (valueType == typeof(decimal))
{
Item = value;
ItemElementName = ItemChoiceType.Decimal;
}
else if (valueType == typeof(double))
{
Item = value;
ItemElementName = ItemChoiceType.Double;
}
else if (valueType == typeof(int))
{
Item = value;
ItemElementName = ItemChoiceType.Int;
}
else if (valueType == typeof(long))
{
Item = value;
ItemElementName = ItemChoiceType.Long;
}
else if (valueType == typeof(short))
{
Item = value;
ItemElementName = ItemChoiceType.Short;
}
else if (valueType == typeof(string))
{
Item = value;
ItemElementName = ItemChoiceType.String;
}
else if (valueType == typeof(Uri))
{
Item = value.ToString();
ItemElementName = ItemChoiceType.URI;
}
else if (valueType == typeof(Guid))
{
Item = value.ToString();
ItemElementName = ItemChoiceType.UUID;
}
else if (valueType == typeof(TimeSpan))
{
Item = value.ToString();
ItemElementName = ItemChoiceType.Duration;
}
else if (valueType.GetInterface("IDictionary`2") != null)
{
Item = new TypedMapType((IDictionary)value);
ItemElementName = ItemChoiceType.TypedMap;
}
else if (typeof(IDictionary).IsAssignableFrom(valueType))
{
Item = new MapType((IDictionary)value);
ItemElementName = ItemChoiceType.Map;
}
else if (valueType.GetInterface("ICollection`1") != null)
{
Item = new TypedMultipleValueType((ICollection)value);
ItemElementName = ItemChoiceType.TypedList;
}
else if (typeof(ICollection).IsAssignableFrom(valueType))
{
Item = new MultipleValueType((ICollection)value);
ItemElementName = ItemChoiceType.List;
}
else if (valueType == typeof(XmlQualifiedName))
{
Item = value;
ItemElementName = ItemChoiceType.QName;
}
else if (valueType == typeof(ObjectName))
{
Item = ObjectNameSelector.CreateEndpointAddress((ObjectName)value);
ItemElementName = ItemChoiceType.EndpointReference;
}
else if (valueType == typeof(RoleInfo))
{
Item = new ManagedResourceRoleInfo((RoleInfo) value);
ItemElementName = ItemChoiceType.ManagedResourceRoleInfo;
}
else if (valueType == typeof(RoleResult))
{
Item = new ManagedResourceRoleResult((RoleResult) value);
ItemElementName = ItemChoiceType.ManagedResourceRoleResult;
}
else if (typeof(ITabularData).IsAssignableFrom(valueType))
{
Item = new TabularDataValueType((ITabularData)value);
ItemElementName = ItemChoiceType.TabularDataValue;
}
else if (typeof(ICompositeData).IsAssignableFrom(valueType))
{
Item = new CompositeDataValueType((ICompositeData)value);
ItemElementName = ItemChoiceType.CompositeDataValue;
}
else if (typeof(OpenType).IsAssignableFrom(valueType))
{
Item = OpenDataType_Type.Serialize(value, out itemElementNameField);
}
else throw new NotSupportedException("Not supported type in serialization: "+valueType);
}
}
public override object Exec(NullType firstOperand, object arg)
{
return(AddTypeExpression(firstOperand));
}
public SpecialNullabilityNode(NullType nullType)
{
this.NullType = nullType;
}
public NullType CreateNull()
{
NullType type = new NullType();
type.SetTypeKind(TypeKind.TK_NullType);
return type;
}
public virtual object Exec(NullType n, object arg)
{
return(Exec((TypeExpression)n, arg));
}
/// <summary>
/// Writes the intialization of a with a NullType
/// </summary>
/// <param name="n">Type Expression representing a NullType</param>
/// <returns>null</returns>
public override object Exec(NullType n, object arg)
{
this.codeGenerator.WriteLNFieldInitialization(" = nullref");
return(null);
}
public SemanticCheckResult()
{
Errors = new List <Error>();
Type = new NullType();
}
