public void CSharpFullQualifiedDefaultValue()
{
DefaultValueExpression toe = ParseUtilCSharp.ParseExpression <DefaultValueExpression>("default(global::MyNamespace.N1.MyType)");
Assert.IsTrue(toe.TypeReference.IsGlobal);
Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type);
}
public UnifiedElement VisitDefaultValueExpression(
DefaultValueExpression expr, object data)
{
var type = LookupType(expr.Type);
return(UnifiedDefault.Create(type));
}
public void CSharpGenericDefaultValue()
{
DefaultValueExpression toe = ParseUtilCSharp.ParseExpression <DefaultValueExpression>("default(MyNamespace.N1.MyType<string>)");
Assert.AreEqual("MyNamespace.N1.MyType", toe.TypeReference.Type);
Assert.AreEqual("System.String", toe.TypeReference.GenericTypes[0].Type);
}
public void CSharpDefaultValueInReturnStatement()
{
ReturnStatement rs = ParseUtilCSharp.ParseStatement <ReturnStatement>("return default(T);");
DefaultValueExpression dve = (DefaultValueExpression)rs.Expression;
Assert.AreEqual("T", dve.TypeReference.Type);
}
public virtual object Visit(DefaultValueExpression defaultValueExpression, object data)
{
Debug.Assert(defaultValueExpression != null);
Debug.Assert(defaultValueExpression.TypeReference != null);
defaultValueExpression.TypeReference.AcceptVisitor(this, data);
return(data);
}
public void CSharpDefaultValueAsIntializer()
{
// This test is failing because we need a resolver for the "default:" / "default(" conflict.
LocalVariableDeclaration lvd = ParseUtilCSharp.ParseStatement <LocalVariableDeclaration>("T a = default(T);");
DefaultValueExpression dve = (DefaultValueExpression)lvd.Variables[0].Initializer;
Assert.AreEqual("T", dve.TypeReference.Type);
}
public void CSharpCodeGenerator_Default()
{
var expr = new DefaultValueExpression(typeof(string));
var generator = new CSharpCodeGenerator();
var result = generator.Write(expr);
Assert.That.StringEquals("default(string)", result);
}
public override object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
{
base.VisitDefaultValueExpression(defaultValueExpression, data);
Expression defaultValue = ExpressionBuilder.CreateDefaultValueForType(defaultValueExpression.TypeReference);
if (!(defaultValue is DefaultValueExpression))
{
ReplaceCurrentNode(defaultValue);
}
return(null);
}
protected virtual IEnumerable <Syntax> TranslateDefaultValueExpression(DefaultValueExpression defaultValueExpression, ILTranslationContext data)
{
var ti = defaultValueExpression.Annotation <TypeInformation>()?.InferredType;
if (ti?.Namespace == nameof(System))
{
switch (ti.Name)
{
case nameof(Boolean):
yield return(new E.BooleanExpression(false));
yield break;
case nameof(Byte):
case nameof(SByte):
case nameof(Int16):
case nameof(UInt16):
case nameof(Int32):
case nameof(UInt32):
case nameof(Int64):
case nameof(UInt64):
case nameof(Single):
case nameof(Double):
case nameof(Decimal):
yield return(new E.NumberExpression(0));
yield break;
}
}
if (ti?.IsValueType == true)
{
var ct = ti.ResolveClrType();
if (ct?.IsEnum == true)
{
var n = Enum.GetName(ct, ((IConvertible)0).ToType(Enum.GetUnderlyingType(ct), null));
if (n == null)
{
yield return(new E.NumberExpression(0));
}
else
{
yield return(new E.IdentifierExpression(ct.FullName).Property(n));
}
yield break;
}
}
yield return(new E.NullExpression());
yield break;
}
public override object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
{
base.VisitDefaultValueExpression(defaultValueExpression, data);
IReturnType type = FixTypeReferenceCasing(defaultValueExpression.TypeReference, defaultValueExpression.StartLocation);
// the VBNetConstructsConvertVisitor will initialize local variables to
// default(TypeReference).
// MyType m = null; looks nicer than MyType m = default(MyType))
// so we replace default(ReferenceType) with null
if (type != null && type.IsReferenceType == true)
{
ReplaceCurrentNode(new PrimitiveExpression(null, "null"));
}
return(null);
}
public override object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
{
base.VisitDefaultValueExpression(defaultValueExpression, data);
IReturnType type = FixTypeReferenceCasing(defaultValueExpression.TypeReference, defaultValueExpression.StartLocation);
// the VBNetConstructsConvertVisitor will initialize local variables to
// default(TypeReference).
// MyType m = null; looks nicer than MyType m = default(MyType))
// so we replace default(ReferenceType) with null
if (type != null && (type.IsDefaultReturnType || type.IsConstructedReturnType))
{
IClass c = type.GetUnderlyingClass();
if (c != null && (c.ClassType == ClassType.Class || c.ClassType == ClassType.Interface || c.ClassType == ClassType.Delegate))
{
ReplaceCurrentNode(new PrimitiveExpression(null, "null"));
}
}
return(null);
}
public Expression ConvertConstantValue(IType type, object constantValue)
{
if (type == null)
throw new ArgumentNullException("type");
if (constantValue == null) {
if (type.IsReferenceType == true) {
var expr = new NullReferenceExpression();
if (AddResolveResultAnnotations)
expr.AddAnnotation(new ConstantResolveResult(SpecialType.NullType, null));
return expr;
} else {
var expr = new DefaultValueExpression(ConvertType(type));
if (AddResolveResultAnnotations)
expr.AddAnnotation(new ConstantResolveResult(type, null));
return expr;
}
} else if (type.Kind == TypeKind.Enum) {
return ConvertEnumValue(type, (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, constantValue, false));
} else {
return new PrimitiveExpression(constantValue);
}
}
public bool HasExpression(ExpressionType type)
{
if (type == ExpressionType.ValueExpression)
{
return(ValueExpr != null && !ValueExpr.IsEmpty());
}
else if (type == ExpressionType.HideExpression)
{
return(HiddenExpr != null && !HiddenExpr.IsEmpty());
}
else if (type == ExpressionType.DisableExpression)
{
return(DisableExpr != null && !DisableExpr.IsEmpty());
}
else if (type == ExpressionType.HideExpression)
{
return(DefaultValueExpression != null && !DefaultValueExpression.IsEmpty());
}
else
{
return(false);
}
}
public void CSharpSimpleDefaultValue()
{
DefaultValueExpression toe = ParseUtilCSharp.ParseExpression <DefaultValueExpression>("default(T)");
Assert.AreEqual("T", toe.TypeReference.Type);
}
internal DefaultValueEmitter(DefaultValueExpression defaultValueExpression, ILGenerator ilGenerator, IOpCodeIndexer instructionsIndexer)
: base(ilGenerator, instructionsIndexer)
{
_defaultValueExpression = defaultValueExpression;
}
public DefaultValueBlock(IEmitter emitter, DefaultValueExpression defaultValueExpression)
: base(emitter, defaultValueExpression)
{
this.Emitter = emitter;
this.DefaultValueExpression = defaultValueExpression;
}
public virtual void VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression)
{
//throw this.CreateException(defaultValueExpression);
}
public override void VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression)
{
HandleExpressionNode(defaultValueExpression);
}
public override void VisitDefaultValueExpression (DefaultValueExpression defaultValueExpression)
{
base.VisitDefaultValueExpression (defaultValueExpression);
var ctor = GetJsConstructor (defaultValueExpression.Type);
object val = null;
switch (ctor) {
case "Number":
val = 0;
break;
case "Boolean":
val = false;
break;
}
defaultValueExpression.ReplaceWith (new PrimitiveExpression (val));
}
public override void VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression)
{
new DefaultValueBlock(this, defaultValueExpression).Emit();
}
public virtual void VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression)
{
DebugExpression(defaultValueExpression);
StartNode(defaultValueExpression);
WriteKeyword(DefaultValueExpression.DefaultKeywordRole);
var braceHelper = BraceHelper.LeftParen(this, CodeBracesRangeFlags.Parentheses);
Space(policy.SpacesWithinTypeOfParentheses);
defaultValueExpression.Type.AcceptVisitor(this);
Space(policy.SpacesWithinTypeOfParentheses);
braceHelper.RightParen();
EndNode(defaultValueExpression);
}
void PrimaryExpr(
#line 1862 "cs.ATG"
out Expression pexpr) {
#line 1864 "cs.ATG"
TypeReference type = null;
Expression expr;
pexpr = null;
#line 1869 "cs.ATG"
Location startLocation = la.Location;
if (la.kind == 113) {
lexer.NextToken();
#line 1871 "cs.ATG"
pexpr = new PrimitiveExpression(true, "true");
} else if (la.kind == 72) {
lexer.NextToken();
#line 1872 "cs.ATG"
pexpr = new PrimitiveExpression(false, "false");
} else if (la.kind == 90) {
lexer.NextToken();
#line 1873 "cs.ATG"
pexpr = new PrimitiveExpression(null, "null");
} else if (la.kind == 2) {
lexer.NextToken();
#line 1874 "cs.ATG"
pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };
} else if (
#line 1875 "cs.ATG"
StartOfQueryExpression()) {
QueryExpression(
#line 1876 "cs.ATG"
out pexpr);
} else if (
#line 1877 "cs.ATG"
IdentAndDoubleColon()) {
Identifier();
#line 1878 "cs.ATG"
type = new TypeReference(t.val);
Expect(10);
#line 1879 "cs.ATG"
pexpr = new TypeReferenceExpression(type);
Identifier();
#line 1880 "cs.ATG"
if (type.Type == "global") { type.IsGlobal = true; type.Type = t.val ?? "?"; } else type.Type += "." + (t.val ?? "?");
} else if (StartOf(19)) {
Identifier();
#line 1884 "cs.ATG"
pexpr = new IdentifierExpression(t.val);
if (la.kind == 48 ||
#line 1887 "cs.ATG"
IsGenericInSimpleNameOrMemberAccess()) {
if (la.kind == 48) {
ShortedLambdaExpression(
#line 1886 "cs.ATG"
(IdentifierExpression)pexpr, out pexpr);
} else {
#line 1888 "cs.ATG"
List<TypeReference> typeList;
TypeArgumentList(
#line 1889 "cs.ATG"
out typeList, false);
#line 1890 "cs.ATG"
((IdentifierExpression)pexpr).TypeArguments = typeList;
}
}
} else if (
#line 1892 "cs.ATG"
IsLambdaExpression()) {
LambdaExpression(
#line 1893 "cs.ATG"
out pexpr);
} else if (la.kind == 20) {
lexer.NextToken();
Expr(
#line 1896 "cs.ATG"
out expr);
Expect(21);
#line 1896 "cs.ATG"
pexpr = new ParenthesizedExpression(expr);
} else if (StartOf(35)) {
#line 1899 "cs.ATG"
string val = null;
switch (la.kind) {
case 52: {
lexer.NextToken();
#line 1900 "cs.ATG"
val = "System.Boolean";
break;
}
case 54: {
lexer.NextToken();
#line 1901 "cs.ATG"
val = "System.Byte";
break;
}
case 57: {
lexer.NextToken();
#line 1902 "cs.ATG"
val = "System.Char";
break;
}
case 62: {
lexer.NextToken();
#line 1903 "cs.ATG"
val = "System.Decimal";
break;
}
case 66: {
lexer.NextToken();
#line 1904 "cs.ATG"
val = "System.Double";
break;
}
case 75: {
lexer.NextToken();
#line 1905 "cs.ATG"
val = "System.Single";
break;
}
case 82: {
lexer.NextToken();
#line 1906 "cs.ATG"
val = "System.Int32";
break;
}
case 87: {
lexer.NextToken();
#line 1907 "cs.ATG"
val = "System.Int64";
break;
}
case 91: {
lexer.NextToken();
#line 1908 "cs.ATG"
val = "System.Object";
break;
}
case 102: {
lexer.NextToken();
#line 1909 "cs.ATG"
val = "System.SByte";
break;
}
case 104: {
lexer.NextToken();
#line 1910 "cs.ATG"
val = "System.Int16";
break;
}
case 108: {
lexer.NextToken();
#line 1911 "cs.ATG"
val = "System.String";
break;
}
case 116: {
lexer.NextToken();
#line 1912 "cs.ATG"
val = "System.UInt32";
break;
}
case 117: {
lexer.NextToken();
#line 1913 "cs.ATG"
val = "System.UInt64";
break;
}
case 120: {
lexer.NextToken();
#line 1914 "cs.ATG"
val = "System.UInt16";
break;
}
case 123: {
lexer.NextToken();
#line 1915 "cs.ATG"
val = "System.Void";
break;
}
}
#line 1917 "cs.ATG"
pexpr = new TypeReferenceExpression(new TypeReference(val, true)) { StartLocation = t.Location, EndLocation = t.EndLocation };
} else if (la.kind == 111) {
lexer.NextToken();
#line 1920 "cs.ATG"
pexpr = new ThisReferenceExpression(); pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
} else if (la.kind == 51) {
lexer.NextToken();
#line 1922 "cs.ATG"
pexpr = new BaseReferenceExpression(); pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
} else if (la.kind == 89) {
NewExpression(
#line 1925 "cs.ATG"
out pexpr);
} else if (la.kind == 115) {
lexer.NextToken();
Expect(20);
if (
#line 1929 "cs.ATG"
NotVoidPointer()) {
Expect(123);
#line 1929 "cs.ATG"
type = new TypeReference("System.Void", true);
} else if (StartOf(10)) {
TypeWithRestriction(
#line 1930 "cs.ATG"
out type, true, true);
} else SynErr(208);
Expect(21);
#line 1932 "cs.ATG"
pexpr = new TypeOfExpression(type);
} else if (la.kind == 63) {
lexer.NextToken();
Expect(20);
Type(
#line 1934 "cs.ATG"
out type);
Expect(21);
#line 1934 "cs.ATG"
pexpr = new DefaultValueExpression(type);
} else if (la.kind == 105) {
lexer.NextToken();
Expect(20);
Type(
#line 1935 "cs.ATG"
out type);
Expect(21);
#line 1935 "cs.ATG"
pexpr = new SizeOfExpression(type);
} else if (la.kind == 58) {
lexer.NextToken();
Expect(20);
Expr(
#line 1936 "cs.ATG"
out expr);
Expect(21);
#line 1936 "cs.ATG"
pexpr = new CheckedExpression(expr);
} else if (la.kind == 118) {
lexer.NextToken();
Expect(20);
Expr(
#line 1937 "cs.ATG"
out expr);
Expect(21);
#line 1937 "cs.ATG"
pexpr = new UncheckedExpression(expr);
} else if (la.kind == 64) {
lexer.NextToken();
AnonymousMethodExpr(
#line 1938 "cs.ATG"
out expr);
#line 1938 "cs.ATG"
pexpr = expr;
} else SynErr(209);
#line 1940 "cs.ATG"
if (pexpr != null) {
if (pexpr.StartLocation.IsEmpty)
pexpr.StartLocation = startLocation;
if (pexpr.EndLocation.IsEmpty)
pexpr.EndLocation = t.EndLocation;
}
while (StartOf(36)) {
if (la.kind == 31 || la.kind == 32) {
#line 1948 "cs.ATG"
startLocation = la.Location;
if (la.kind == 31) {
lexer.NextToken();
#line 1950 "cs.ATG"
pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostIncrement);
} else if (la.kind == 32) {
lexer.NextToken();
#line 1951 "cs.ATG"
pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostDecrement);
} else SynErr(210);
} else if (la.kind == 47) {
PointerMemberAccess(
#line 1954 "cs.ATG"
out pexpr, pexpr);
} else if (la.kind == 15) {
MemberAccess(
#line 1955 "cs.ATG"
out pexpr, pexpr);
} else if (la.kind == 20) {
lexer.NextToken();
#line 1959 "cs.ATG"
List<Expression> parameters = new List<Expression>();
#line 1960 "cs.ATG"
pexpr = new InvocationExpression(pexpr, parameters);
if (StartOf(26)) {
Argument(
#line 1961 "cs.ATG"
out expr);
#line 1961 "cs.ATG"
SafeAdd(pexpr, parameters, expr);
while (la.kind == 14) {
lexer.NextToken();
Argument(
#line 1962 "cs.ATG"
out expr);
#line 1962 "cs.ATG"
SafeAdd(pexpr, parameters, expr);
}
}
Expect(21);
} else {
#line 1968 "cs.ATG"
List<Expression> indices = new List<Expression>();
pexpr = new IndexerExpression(pexpr, indices);
lexer.NextToken();
Expr(
#line 1971 "cs.ATG"
out expr);
#line 1971 "cs.ATG"
SafeAdd(pexpr, indices, expr);
while (la.kind == 14) {
lexer.NextToken();
Expr(
#line 1972 "cs.ATG"
out expr);
#line 1972 "cs.ATG"
SafeAdd(pexpr, indices, expr);
}
Expect(19);
#line 1975 "cs.ATG"
if (pexpr != null) {
pexpr.StartLocation = startLocation;
pexpr.EndLocation = t.EndLocation;
}
}
}
}
public virtual object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
throw new global::System.NotImplementedException("DefaultValueExpression");
}
public virtual object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
Debug.Assert((defaultValueExpression != null));
Debug.Assert((defaultValueExpression.TypeReference != null));
return defaultValueExpression.TypeReference.AcceptVisitor(this, data);
}
public void VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression)
{
JsonObject expression = CreateJsonExpression(defaultValueExpression);
AddKeyword(expression, DefaultValueExpression.DefaultKeywordRole);
expression.AddJsonValue("type-info", GenTypeInfo(defaultValueExpression.Type));
Push(expression);
}
public virtual object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
Debug.Assert((defaultValueExpression != null));
Debug.Assert((defaultValueExpression.TypeReference != null));
nodeStack.Push(defaultValueExpression.TypeReference);
defaultValueExpression.TypeReference.AcceptVisitor(this, data);
defaultValueExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
return null;
}
public virtual object TrackedVisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
return base.VisitDefaultValueExpression(defaultValueExpression, data);
}
public Expression ConvertConstantValue(IType type, object constantValue)
{
if (type == null)
throw new ArgumentNullException("type");
if (constantValue == null) {
if (type.IsReferenceType == true) {
var expr = new NullReferenceExpression();
if (AddResolveResultAnnotations)
expr.AddAnnotation(new ConstantResolveResult(SpecialType.NullType, null));
return expr;
} else {
var expr = new DefaultValueExpression(ConvertType(type));
if (AddResolveResultAnnotations)
expr.AddAnnotation(new ConstantResolveResult(type, null));
return expr;
}
} else if (type.Kind == TypeKind.Enum) {
return ConvertEnumValue(type, (long)CSharpPrimitiveCast.Cast(TypeCode.Int64, constantValue, false));
} else {
return new PrimitiveExpression(constantValue);
}
}
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
{
DefaultValueExpression o = other as DefaultValueExpression;
return(o != null && this.Type.DoMatch(o.Type, match));
}
private void Format_Default_Value_Expression(StringBuilder sb, DefaultValueExpression expression)
{
sb.Append("default(").Append(FormatterUtility.FormatDataType(expression.ReturnType, document, controller)).Append(")");
}
public virtual void VisitDefaultValueExpression(DefaultValueExpression syntax)
{
VisitNode(syntax);
}
public override StringBuilder VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, int data)
{
throw new NotImplementedException();
}
//
// Imports System.Reflection parameters
//
AParametersCollection CreateParameters (TypeSpec parent, ParameterInfo[] pi, MethodBase method)
{
int varargs = method != null && (method.CallingConvention & CallingConventions.VarArgs) != 0 ? 1 : 0;
if (pi.Length == 0 && varargs == 0)
return ParametersCompiled.EmptyReadOnlyParameters;
TypeSpec[] types = new TypeSpec[pi.Length + varargs];
IParameterData[] par = new IParameterData[pi.Length + varargs];
bool is_params = false;
for (int i = 0; i < pi.Length; i++) {
ParameterInfo p = pi[i];
Parameter.Modifier mod = 0;
Expression default_value = null;
if (p.ParameterType.IsByRef) {
if ((p.Attributes & (ParameterAttributes.Out | ParameterAttributes.In)) == ParameterAttributes.Out)
mod = Parameter.Modifier.OUT;
else
mod = Parameter.Modifier.REF;
//
// Strip reference wrapping
//
var el = p.ParameterType.GetElementType ();
types[i] = ImportType (el, new DynamicTypeReader (p)); // TODO: 1-based positio to be csc compatible
} else if (i == 0 && method.IsStatic && (parent.Modifiers & Modifiers.METHOD_EXTENSION) != 0 &&
HasAttribute (CustomAttributeData.GetCustomAttributes (method), "ExtensionAttribute", CompilerServicesNamespace)) {
mod = Parameter.Modifier.This;
types[i] = ImportType (p.ParameterType, new DynamicTypeReader (p));
} else {
types[i] = ImportType (p.ParameterType, new DynamicTypeReader (p));
if (i >= pi.Length - 2 && types[i] is ArrayContainer) {
if (HasAttribute (CustomAttributeData.GetCustomAttributes (p), "ParamArrayAttribute", "System")) {
mod = Parameter.Modifier.PARAMS;
is_params = true;
}
}
if (!is_params && p.IsOptional) {
object value = p.RawDefaultValue;
var ptype = types[i];
if ((p.Attributes & ParameterAttributes.HasDefault) != 0 && ptype.Kind != MemberKind.TypeParameter && (value != null || TypeSpec.IsReferenceType (ptype))) {
if (value == null) {
default_value = Constant.CreateConstantFromValue (ptype, null, Location.Null);
} else {
default_value = ImportParameterConstant (value);
if (ptype.IsEnum) {
default_value = new EnumConstant ((Constant) default_value, ptype);
}
}
var attrs = CustomAttributeData.GetCustomAttributes (p);
for (int ii = 0; ii < attrs.Count; ++ii) {
var attr = attrs[ii];
var dt = attr.Constructor.DeclaringType;
if (dt.Namespace != CompilerServicesNamespace)
continue;
if (dt.Name == "CallerLineNumberAttribute" && (ptype.BuiltinType == BuiltinTypeSpec.Type.Int || Convert.ImplicitNumericConversionExists (module.Compiler.BuiltinTypes.Int, ptype)))
mod |= Parameter.Modifier.CallerLineNumber;
else if (dt.Name == "CallerFilePathAttribute" && Convert.ImplicitReferenceConversionExists (module.Compiler.BuiltinTypes.String, ptype))
mod |= Parameter.Modifier.CallerFilePath;
else if (dt.Name == "CallerMemberNameAttribute" && Convert.ImplicitReferenceConversionExists (module.Compiler.BuiltinTypes.String, ptype))
mod |= Parameter.Modifier.CallerMemberName;
}
} else if (value == Missing.Value) {
default_value = EmptyExpression.MissingValue;
} else if (value == null) {
default_value = new DefaultValueExpression (new TypeExpression (ptype, Location.Null), Location.Null);
} else if (ptype.BuiltinType == BuiltinTypeSpec.Type.Decimal) {
default_value = ImportParameterConstant (value);
}
}
}
par[i] = new ParameterData (p.Name, mod, default_value);
}
if (varargs != 0) {
par[par.Length - 1] = new ArglistParameter (Location.Null);
types[types.Length - 1] = InternalType.Arglist;
}
return method != null ?
new ParametersImported (par, types, varargs != 0, is_params) :
new ParametersImported (par, types, is_params);
}
internal DefaultValueEmitter(DefaultValueExpression defaultValueExpression, ILGenerator ilGenerator, IOpCodeIndexer instructionsIndexer)
: base(ilGenerator, instructionsIndexer) {
_defaultValueExpression = defaultValueExpression;
}
public override void VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression)
{
}
private void VariableInitializer(out Expression initializerExpression)
{
TypeReference type = null;
Expression expr = null;
initializerExpression = null;
if (this.StartOf(5))
{
this.Expr(out initializerExpression);
}
else if (this.la.kind == 0x10)
{
this.ArrayInitializer(out initializerExpression);
}
else if (this.la.kind == 0x69)
{
base.lexer.NextToken();
this.Type(out type);
base.Expect(0x12);
this.Expr(out expr);
base.Expect(0x13);
initializerExpression = new StackAllocExpression(type, expr);
}
else if (this.la.kind == 0x3e)
{
base.lexer.NextToken();
base.Expect(20);
this.Type(out type);
base.Expect(0x15);
initializerExpression = new DefaultValueExpression(type);
}
else
{
base.SynErr(0xa7);
}
}
public object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
{
AddError(defaultValueExpression, "default() is not supported.");
return(null);
}
public override StringBuilder VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, int data)
{
throw new NotImplementedException();
}
public override void VisitDefaultValueExpression(DefaultValueExpression syntax)
{
_underlyingVisitor.VisitDefaultValueExpression(syntax);
}
public override object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
{
return(CreateReturnType(defaultValueExpression.TypeReference));
}
private void PrimaryExpr(out Expression pexpr)
{
TypeReference typeReference = null;
List<TypeReference> types = null;
Expression expression;
bool flag = false;
pexpr = null;
if (this.la.kind == 0x70)
{
base.lexer.NextToken();
pexpr = new PrimitiveExpression(true, "true");
}
else if (this.la.kind == 0x47)
{
base.lexer.NextToken();
pexpr = new PrimitiveExpression(false, "false");
}
else if (this.la.kind == 0x59)
{
base.lexer.NextToken();
pexpr = new PrimitiveExpression(null, "null");
}
else if (this.la.kind == 2)
{
base.lexer.NextToken();
pexpr = new PrimitiveExpression(this.t.literalValue, this.t.val);
}
else if ((this.la.kind == 1) && (this.Peek(1).kind == 10))
{
base.Expect(1);
typeReference = new TypeReference(this.t.val);
base.Expect(10);
pexpr = new TypeReferenceExpression(typeReference);
base.Expect(1);
if (typeReference.Type == "global")
{
typeReference.IsGlobal = true;
typeReference.Type = this.t.val ?? "?";
}
else
{
typeReference.Type = typeReference.Type + "." + (this.t.val ?? "?");
}
}
else if (this.la.kind == 1)
{
base.lexer.NextToken();
pexpr = new IdentifierExpression(this.t.val);
}
else if (this.la.kind == 20)
{
base.lexer.NextToken();
this.Expr(out expression);
base.Expect(0x15);
pexpr = new ParenthesizedExpression(expression);
}
else if (!this.StartOf(0x1a))
{
if (this.la.kind == 110)
{
base.lexer.NextToken();
pexpr = new ThisReferenceExpression();
}
else if (this.la.kind == 50)
{
base.lexer.NextToken();
Expression targetObject = new BaseReferenceExpression();
if (this.la.kind == 15)
{
base.lexer.NextToken();
base.Expect(1);
targetObject = new FieldReferenceExpression(targetObject, this.t.val);
}
else if (this.la.kind == 0x12)
{
base.lexer.NextToken();
this.Expr(out expression);
List<Expression> indices = new List<Expression>();
if (expression != null)
{
indices.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
this.Expr(out expression);
if (expression != null)
{
indices.Add(expression);
}
}
base.Expect(0x13);
targetObject = new IndexerExpression(targetObject, indices);
}
else
{
base.SynErr(0xb3);
}
pexpr = targetObject;
}
else if (this.la.kind == 0x58)
{
base.lexer.NextToken();
this.NonArrayType(out typeReference);
List<Expression> parameters = new List<Expression>();
if (this.la.kind == 20)
{
base.lexer.NextToken();
ObjectCreateExpression expression3 = new ObjectCreateExpression(typeReference, parameters);
if (this.StartOf(0x15))
{
this.Argument(out expression);
if (expression != null)
{
parameters.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
this.Argument(out expression);
if (expression != null)
{
parameters.Add(expression);
}
}
}
base.Expect(0x15);
pexpr = expression3;
}
else if (this.la.kind == 0x12)
{
base.lexer.NextToken();
flag = true;
ArrayCreateExpression expression4 = new ArrayCreateExpression(typeReference);
pexpr = expression4;
int item = 0;
List<int> list4 = new List<int>();
if ((this.la.kind == 14) || (this.la.kind == 0x13))
{
while (this.la.kind == 14)
{
base.lexer.NextToken();
item++;
}
base.Expect(0x13);
list4.Add(item);
item = 0;
while (this.la.kind == 0x12)
{
base.lexer.NextToken();
while (this.la.kind == 14)
{
base.lexer.NextToken();
item++;
}
base.Expect(0x13);
list4.Add(item);
item = 0;
}
expression4.CreateType.RankSpecifier = list4.ToArray();
this.ArrayInitializer(out expression);
expression4.ArrayInitializer = (ArrayInitializerExpression) expression;
}
else if (this.StartOf(5))
{
this.Expr(out expression);
if (expression != null)
{
parameters.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
item++;
this.Expr(out expression);
if (expression != null)
{
parameters.Add(expression);
}
}
base.Expect(0x13);
list4.Add(item);
expression4.Arguments = parameters;
for (item = 0; this.la.kind == 0x12; item = 0)
{
base.lexer.NextToken();
while (this.la.kind == 14)
{
base.lexer.NextToken();
item++;
}
base.Expect(0x13);
list4.Add(item);
}
expression4.CreateType.RankSpecifier = list4.ToArray();
if (this.la.kind == 0x10)
{
this.ArrayInitializer(out expression);
expression4.ArrayInitializer = (ArrayInitializerExpression) expression;
}
}
else
{
base.SynErr(180);
}
}
else
{
base.SynErr(0xb5);
}
}
else if (this.la.kind == 0x72)
{
base.lexer.NextToken();
base.Expect(20);
if (this.NotVoidPointer())
{
base.Expect(0x7a);
typeReference = new TypeReference("void");
}
else if (this.StartOf(9))
{
this.TypeWithRestriction(out typeReference, true, true);
}
else
{
base.SynErr(0xb6);
}
base.Expect(0x15);
pexpr = new TypeOfExpression(typeReference);
}
else if ((this.la.kind == 0x3e) && (this.Peek(1).kind == 20))
{
base.Expect(0x3e);
base.Expect(20);
this.Type(out typeReference);
base.Expect(0x15);
pexpr = new DefaultValueExpression(typeReference);
}
else if (this.la.kind == 0x68)
{
base.lexer.NextToken();
base.Expect(20);
this.Type(out typeReference);
base.Expect(0x15);
pexpr = new SizeOfExpression(typeReference);
}
else if (this.la.kind == 0x39)
{
base.lexer.NextToken();
base.Expect(20);
this.Expr(out expression);
base.Expect(0x15);
pexpr = new CheckedExpression(expression);
}
else if (this.la.kind == 0x75)
{
base.lexer.NextToken();
base.Expect(20);
this.Expr(out expression);
base.Expect(0x15);
pexpr = new UncheckedExpression(expression);
}
else if (this.la.kind == 0x3f)
{
base.lexer.NextToken();
this.AnonymousMethodExpr(out expression);
pexpr = expression;
}
else
{
base.SynErr(0xb7);
}
}
else
{
string typeName = null;
switch (this.la.kind)
{
case 0x3d:
base.lexer.NextToken();
typeName = "decimal";
break;
case 0x41:
base.lexer.NextToken();
typeName = "double";
break;
case 0x4a:
base.lexer.NextToken();
typeName = "float";
break;
case 0x33:
base.lexer.NextToken();
typeName = "bool";
break;
case 0x35:
base.lexer.NextToken();
typeName = "byte";
break;
case 0x38:
base.lexer.NextToken();
typeName = "char";
break;
case 0x51:
base.lexer.NextToken();
typeName = "int";
break;
case 0x56:
base.lexer.NextToken();
typeName = "long";
break;
case 90:
base.lexer.NextToken();
typeName = "object";
break;
case 0x65:
base.lexer.NextToken();
typeName = "sbyte";
break;
case 0x67:
base.lexer.NextToken();
typeName = "short";
break;
case 0x6b:
base.lexer.NextToken();
typeName = "string";
break;
case 0x73:
base.lexer.NextToken();
typeName = "uint";
break;
case 0x74:
base.lexer.NextToken();
typeName = "ulong";
break;
case 0x77:
base.lexer.NextToken();
typeName = "ushort";
break;
}
this.t.val = "";
base.Expect(15);
base.Expect(1);
pexpr = new FieldReferenceExpression(new TypeReferenceExpression(typeName), this.t.val);
}
while ((this.StartOf(0x1b) || (this.IsGenericFollowedBy(15) && this.IsTypeReferenceExpression(pexpr))) || this.IsGenericFollowedBy(20))
{
if ((this.la.kind == 0x1f) || (this.la.kind == 0x20))
{
if (this.la.kind == 0x1f)
{
base.lexer.NextToken();
pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostIncrement);
}
else if (this.la.kind == 0x20)
{
base.lexer.NextToken();
pexpr = new UnaryOperatorExpression(pexpr, UnaryOperatorType.PostDecrement);
}
else
{
base.SynErr(0xb8);
}
}
else
{
if (this.la.kind == 0x2f)
{
base.lexer.NextToken();
base.Expect(1);
pexpr = new PointerReferenceExpression(pexpr, this.t.val);
continue;
}
if (this.la.kind == 15)
{
base.lexer.NextToken();
base.Expect(1);
pexpr = new FieldReferenceExpression(pexpr, this.t.val);
continue;
}
if (this.IsGenericFollowedBy(15) && this.IsTypeReferenceExpression(pexpr))
{
this.TypeArgumentList(out types, false);
base.Expect(15);
base.Expect(1);
pexpr = new FieldReferenceExpression(this.GetTypeReferenceExpression(pexpr, types), this.t.val);
continue;
}
if (this.la.kind == 20)
{
base.lexer.NextToken();
List<Expression> arguments = new List<Expression>();
if (this.StartOf(0x15))
{
this.Argument(out expression);
if (expression != null)
{
arguments.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
this.Argument(out expression);
if (expression != null)
{
arguments.Add(expression);
}
}
}
base.Expect(0x15);
pexpr = new InvocationExpression(pexpr, arguments);
continue;
}
if (this.IsGenericFollowedBy(20))
{
this.TypeArgumentList(out types, false);
base.Expect(20);
List<Expression> list6 = new List<Expression>();
if (this.StartOf(0x15))
{
this.Argument(out expression);
if (expression != null)
{
list6.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
this.Argument(out expression);
if (expression != null)
{
list6.Add(expression);
}
}
}
base.Expect(0x15);
pexpr = new InvocationExpression(pexpr, list6, types);
continue;
}
if (flag)
{
this.Error("element access not allow on array creation");
}
List<Expression> list7 = new List<Expression>();
base.lexer.NextToken();
this.Expr(out expression);
if (expression != null)
{
list7.Add(expression);
}
while (this.la.kind == 14)
{
base.lexer.NextToken();
this.Expr(out expression);
if (expression != null)
{
list7.Add(expression);
}
}
base.Expect(0x13);
pexpr = new IndexerExpression(pexpr, list7);
}
}
}
public override void VisitReturnStatement(ReturnStatement returnStatement)
{
base.VisitReturnStatement(returnStatement);
if (skip)
{
return;
}
if (returnStatement.Expression.IsNull)
{
var entity = returnStatement.GetParent <EntityDeclaration>();
if (entity is Accessor)
{
entity = entity.GetParent <EntityDeclaration>();
}
if (entity == null)
{
return;
}
AstNode entityNode;
var rr = GetRequestedReturnType(ctx, returnStatement, out entityNode);
var actions = new List <CodeAction>();
if (rr != null)
{
actions.Add(new CodeAction(ctx.TranslateString("Return default value"), script => {
Expression p;
if (rr.IsKnownType(KnownTypeCode.Boolean))
{
p = new PrimitiveExpression(false);
}
else if (rr.IsKnownType(KnownTypeCode.String))
{
p = new PrimitiveExpression("");
}
else if (rr.IsKnownType(KnownTypeCode.Char))
{
p = new PrimitiveExpression(' ');
}
else if (rr.IsReferenceType == true)
{
p = new NullReferenceExpression();
}
else if (rr.GetDefinition() != null &&
rr.GetDefinition().KnownTypeCode < KnownTypeCode.DateTime)
{
p = new PrimitiveExpression(0x0);
}
else
{
p = new DefaultValueExpression(ctx.CreateTypeSystemAstBuilder(returnStatement).ConvertType(rr));
}
script.Replace(returnStatement, new ReturnStatement(p));
}, returnStatement));
}
var method = returnStatement.GetParent <MethodDeclaration>();
if (method != null)
{
actions.Add(new CodeAction(ctx.TranslateString("Change method return type to 'void'"), script => {
script.Replace(method.ReturnType, new PrimitiveType("void"));
}, returnStatement));
}
AddIssue(
returnStatement,
string.Format(ctx.TranslateString("`{0}': A return keyword must be followed by any expression when method returns a value"), currentMethodName),
actions
);
}
}
void case_553()
#line 4757 "ps-parser.jay"
{
CheckIsPlayScript("default values", GetLocation(yyVals[-3+yyTop]));
if (lang_version < LanguageVersion.ISO_2)
FeatureIsNotAvailable (GetLocation (yyVals[-3+yyTop]), "default value expression");
yyVal = new DefaultValueExpression ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-3+yyTop]));
lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
}
public void VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression)
{
StartNode(defaultValueExpression);
WriteKeyword(DefaultValueExpression.DefaultKeywordRole);
LPar();
Space(policy.SpacesWithinTypeOfParentheses);
defaultValueExpression.Type.AcceptVisitor(this);
Space(policy.SpacesWithinTypeOfParentheses);
RPar();
EndNode(defaultValueExpression);
}
void case_597()
#line 4345 "cs-parser.jay"
{
if (lang_version < LanguageVersion.ISO_2)
FeatureIsNotAvailable (GetLocation (yyVals[-3+yyTop]), "default value expression");
yyVal = new DefaultValueExpression ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-3+yyTop]));
lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
}
public sealed override object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
BeginVisit(defaultValueExpression);
object result = TrackedVisitDefaultValueExpression(defaultValueExpression, data);
EndVisit(defaultValueExpression);
return result;
}
public virtual object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
{
throw new global::System.NotImplementedException("DefaultValueExpression");
}
public virtual object Visit (DefaultValueExpression defaultValueExpression)
{
return null;
}
public override object Visit (Mono.CSharpPs.DefaultValueExpression defaultValueExpression)
{
var result = new DefaultValueExpression ();
result.AddChild (new CSharpTokenNode (Convert (defaultValueExpression.Location), DefaultValueExpression.DefaultKeywordRole), DefaultValueExpression.DefaultKeywordRole);
var location = LocationsBag.GetLocations (defaultValueExpression);
if (location != null)
result.AddChild (new CSharpTokenNode (Convert (location [0]), Roles.LPar), Roles.LPar);
result.AddChild (ConvertToType (defaultValueExpression.Expr), Roles.Type);
if (location != null && location.Count > 1)
result.AddChild (new CSharpTokenNode (Convert (location [1]), Roles.RPar), Roles.RPar);
return result;
}
public void VisitDefaultValueExpression(DefaultValueExpression node)
{
VisitChildren(node);
// Generate the default value now
var result = resolver.Resolve(node.Type) as TypeResolveResult;
if (result != null) {
node.ReplaceWith(CreateDefaultValue(result.Type));
}
}
public virtual object Visit(DefaultValueExpression defaultValueExpression)
{
return(null);
}
public override void VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression)
{
new DefaultValueBlock(this, defaultValueExpression).Emit();
}
/// <summary>
/// Translates a default value expression, e.g. "float3()".
/// </summary>
public override StringBuilder VisitDefaultValueExpression(DefaultValueExpression defaultValueExpr)
{
var type = defaultValueExpr.Type.AcceptVisitor(this);
return(new StringBuilder().Method(type.ToString(), "0"));
}
public abstract StringBuilder VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, int data);
public virtual void VisitDefaultValueExpression (DefaultValueExpression defaultValueExpression)
{
VisitChildren (defaultValueExpression);
}
public DefaultValueBlock(IEmitter emitter, DefaultValueExpression defaultValueExpression)
: base(emitter, defaultValueExpression)
{
this.Emitter = emitter;
this.DefaultValueExpression = defaultValueExpression;
}
public AParametersCollection Inflate (TypeParameterInflator inflator)
{
TypeSpec[] inflated_types = null;
bool default_value = false;
for (int i = 0; i < Count; ++i) {
var inflated_param = inflator.Inflate (types[i]);
if (inflated_types == null) {
if (inflated_param == types[i])
continue;
default_value |= FixedParameters[i].HasDefaultValue;
inflated_types = new TypeSpec[types.Length];
Array.Copy (types, inflated_types, types.Length);
} else {
if (inflated_param == types[i])
continue;
default_value |= FixedParameters[i].HasDefaultValue;
}
inflated_types[i] = inflated_param;
}
if (inflated_types == null)
return this;
var clone = (AParametersCollection) MemberwiseClone ();
clone.types = inflated_types;
//
// Default expression is original expression from the parameter
// declaration context which can be of nested enum in generic class type.
// In such case we end up with expression type of G<T>.E and e.g. parameter
// type of G<int>.E and conversion would fail without inflate in this
// context.
//
if (default_value) {
clone.parameters = new IParameterData[Count];
for (int i = 0; i < Count; ++i) {
var fp = FixedParameters[i];
clone.FixedParameters[i] = fp;
if (!fp.HasDefaultValue)
continue;
var expr = fp.DefaultValue;
if (inflated_types[i] == expr.Type)
continue;
if (expr is DefaultValueExpression)
expr = new DefaultValueExpression (new TypeExpression (inflated_types[i], expr.Location), expr.Location);
else if (expr is Constant)
expr = Constant.CreateConstantFromValue (inflated_types[i], ((Constant) expr).GetValue (), expr.Location);
clone.FixedParameters[i] = new ParameterData (fp.Name, fp.ModFlags, expr);
}
}
return clone;
}
public virtual void VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression)
{
//throw this.CreateException(defaultValueExpression);
}
