return null;
ExpressionStatement es = e as ExpressionStatement;
- if (es == null || e is AnonymousMethodBody)
+ if (es == null || e is AnonymousMethodBody) {
+ var reduced = e as IReducedExpressionStatement;
+ if (reduced != null) {
+ return EmptyExpressionStatement.Instance;
+ }
+
Error_InvalidExpressionStatement (ec);
+ }
//
// This is quite expensive warning, try to limit the damage
}
}
+ interface IReducedExpressionStatement
+ {
+ }
+
/// <summary>
/// This kind of cast is used to encapsulate the child
/// whose type is child.Type into an expression that is
//
public class ReducedExpression : Expression
{
- public sealed class ReducedConstantExpression : EmptyConstantCast
+ public class ReducedConstantExpression : EmptyConstantCast
{
readonly Expression orig_expr;
}
}
+ sealed class ReducedConstantStatement : ReducedConstantExpression, IReducedExpressionStatement
+ {
+ public ReducedConstantStatement (Constant expr, Expression origExpr)
+ : base (expr, origExpr)
+ {
+ }
+ }
+
sealed class ReducedExpressionStatement : ExpressionStatement
{
readonly Expression orig_expr;
//
// Creates fully resolved expression switcher
//
- public static Constant Create (Constant expr, Expression original_expr)
+ public static Constant Create (Constant expr, Expression originalExpr)
{
if (expr.eclass == ExprClass.Unresolved)
throw new ArgumentException ("Unresolved expression");
- return new ReducedConstantExpression (expr, original_expr);
+ if (originalExpr is ExpressionStatement)
+ return new ReducedConstantStatement (expr, originalExpr);
+
+ return new ReducedConstantExpression (expr, originalExpr);
}
public static ExpressionStatement Create (ExpressionStatement s, Expression orig)
pe.Getter = pe.PropertyInfo.Get;
} else {
- if (!pe.PropertyInfo.HasSet || !pe.PropertyInfo.Set.IsAccessible (rc))
+ if (rc.HasSet (ResolveContext.Options.ConstructorScope) && pe.IsAutoPropertyAccess &&
+ pe.PropertyInfo.DeclaringType == rc.CurrentType && pe.IsStatic == rc.IsStatic) {
+ var p = (Property) pe.PropertyInfo.MemberDefinition;
+ return new FieldExpr (p.BackingField, loc);
+ }
+
+ if (!pe.PropertyInfo.HasSet || !pe.PropertyInfo.Set.IsAccessible (rc)) {
+ variable_found = true;
break;
+ }
pe.Setter = pe.PropertyInfo.Set;
}
// Obsolete checks cannot be done when resolving base context as they
// require type dependencies to be set but we are in process of resolving them
//
- if (!(mc is TypeDefinition.BaseContext) && !(mc is UsingAliasNamespace.AliasContext)) {
- ObsoleteAttribute obsolete_attr = type.GetAttributeObsolete ();
- if (obsolete_attr != null && !mc.IsObsolete) {
- AttributeTester.Report_ObsoleteMessage (obsolete_attr, te.GetSignatureForError (), Location, mc.Module.Compiler.Report);
- }
+ if (mc is ResolveContext) {
+ var oa = type.GetAttributeObsolete ();
+ if (oa != null && !mc.IsObsolete)
+ AttributeTester.Report_ObsoleteMessage (oa, type.GetSignatureForError (), fne.Location, mc.Module.Compiler.Report);
}
return type;
ImportedTypeDefinition.Error_MissingDependency (rc, dep, loc);
}
- if (!rc.IsObsolete) {
- ObsoleteAttribute oa = member.GetAttributeObsolete ();
- if (oa != null)
- AttributeTester.Report_ObsoleteMessage (oa, member.GetSignatureForError (), loc, rc.Report);
- }
+ member.CheckObsoleteness (rc, loc);
if (!(member is FieldSpec))
member.MemberDefinition.SetIsUsed ();
if (InstanceExpression is TypeExpr) {
var t = InstanceExpression.Type;
do {
- ObsoleteAttribute oa = t.GetAttributeObsolete ();
- if (oa != null && !rc.IsObsolete) {
- AttributeTester.Report_ObsoleteMessage (oa, t.GetSignatureForError (), loc, rc.Report);
- }
+ t.CheckObsoleteness (rc, loc);
t = t.DeclaringType;
} while (t != null);
//
// Check ObsoleteAttribute on the best method
//
- ObsoleteAttribute oa = best_candidate.GetAttributeObsolete ();
- if (oa != null && !rc.IsObsolete)
- AttributeTester.Report_ObsoleteMessage (oa, best_candidate.GetSignatureForError (), loc, rc.Report);
+ best_candidate.CheckObsoleteness (rc, loc);
best_candidate.MemberDefinition.SetIsUsed ();
}
public override Expression DoResolveLValue (ResolveContext ec, Expression right_side)
{
- if (ConditionalAccess)
+ if (HasConditionalAccess ())
Error_NullPropagatingLValue (ec);
if (spec is FixedFieldSpec) {
return;
}
- if (TypeSpec.IsValueType (InstanceExpression.Type) && InstanceExpression is VariableReference)
+ if (TypeSpec.IsValueType (InstanceExpression.Type)) {
+ var le = SkipLeftValueTypeAccess (InstanceExpression);
+ if (le != null)
+ le.FlowAnalysis (fc);
+
return;
+ }
}
base.FlowAnalysis (fc);
fc.ConditionalAccessEnd ();
}
+ static Expression SkipLeftValueTypeAccess (Expression expr)
+ {
+ if (!TypeSpec.IsValueType (expr.Type))
+ return expr;
+
+ if (expr is VariableReference)
+ return null;
+
+ var fe = expr as FieldExpr;
+ if (fe == null)
+ return expr;
+
+ if (fe.InstanceExpression == null)
+ return expr;
+
+ return SkipLeftValueTypeAccess (fe.InstanceExpression);
+ }
+
public override int GetHashCode ()
{
return spec.GetHashCode ();
if (!rc.HasSet (ResolveContext.Options.ConstructorScope))
return false;
+ if (prop.Parent.PartialContainer != rc.CurrentMemberDefinition.Parent.PartialContainer) {
+ var ps = MemberCache.FindMember (rc.CurrentType, MemberFilter.Property (prop.ShortName, prop.MemberType), BindingRestriction.DeclaredOnly) as PropertySpec;
+ if (ps == null)
+ return false;
+
+ prop = (Property) ps.MemberDefinition;
+ }
+
var spec = prop.BackingField;
if (spec == null)
return false;
public override Expression DoResolveLValue (ResolveContext rc, Expression right_side)
{
- if (ConditionalAccess)
+ if (HasConditionalAccess ())
Error_NullPropagatingLValue (rc);
if (right_side == EmptyExpression.OutAccess) {
spec.MemberDefinition.SetIsUsed ();
- if (!ec.IsObsolete) {
- ObsoleteAttribute oa = spec.GetAttributeObsolete ();
- if (oa != null)
- AttributeTester.Report_ObsoleteMessage (oa, spec.GetSignatureForError (), loc, ec.Report);
- }
+ spec.CheckObsoleteness (ec, loc);
if ((spec.Modifiers & (Modifiers.ABSTRACT | Modifiers.EXTERN)) != 0)
Error_AssignmentEventOnly (ec);
return null;
}
- if (ConditionalAccess)
+ if (HasConditionalAccess ())
Error_NullPropagatingLValue (ec);
op = CandidateToBaseOverride (ec, op);
}
}
- public static TemporaryVariableReference Create (TypeSpec type, Block block, Location loc)
+ public static TemporaryVariableReference Create (TypeSpec type, Block block, Location loc, bool writeToSymbolFile = false)
{
- var li = LocalVariable.CreateCompilerGenerated (type, block, loc);
+ var li = LocalVariable.CreateCompilerGenerated (type, block, loc, writeToSymbolFile);
return new TemporaryVariableReference (li, loc);
}
projects / mono.git / blobdiff