private void Visit(
InstanceExpression expression,
QualifiedModuleName module,
Declaration scope,
Declaration parent,
bool isAssignmentTarget,
bool hasExplicitLetStatement,
bool isSetAssignment)
{
var callSiteContext = expression.Context;
var identifier = expression.Context.GetText();
var callee = expression.ReferencedDeclaration;
expression.ReferencedDeclaration.AddReference(
module,
scope,
parent,
callSiteContext,
identifier,
callee,
callSiteContext.GetSelection(),
_annotationService.FindAnnotations(module, callSiteContext.GetSelection().StartLine),
isAssignmentTarget,
hasExplicitLetStatement,
isSetAssignment);
}
bool InstanceResolve(ParseContext ec, bool leftInstance, bool mustDoCs1540Check)
{
if (_isStatic)
{
InstanceExpression = null;
return(true);
}
if (InstanceExpression == null)
{
// TODO: SimpleName.Error_ObjectRefRequired(ec, loc, GetSignatureForError());
return(false);
}
InstanceExpression = InstanceExpression.DoResolve(ec);
if (leftInstance && InstanceExpression != null)
{
InstanceExpression = InstanceExpression.ResolveLValue(ec, EmptyExpression.LValueMemberAccess);
}
if (InstanceExpression == null)
{
return(false);
}
if (mustDoCs1540Check && (InstanceExpression != EmptyExpression.Null) &&
!TypeManager.IsInstantiationOfSameGenericType(InstanceExpression.Type, null) &&
!TypeManager.IsNestedChildOf(null, InstanceExpression.Type))
{
return(false);
}
return(true);
}
/// <summary>
/// Nested Closure to define a child dependency inline
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public SmartInstance <T> Is(Action <IInstanceExpression <CHILD> > action)
{
var expression = new InstanceExpression <CHILD>(i => _instance.SetChild(_propertyName, i));
action(expression);
return(_instance);
}
/// <summary>
/// Nested Closure to define a child dependency inline
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public TInstance Is(Action <IInstanceExpression <TChild> > action)
{
var expression = new InstanceExpression <TChild>(i => _instance.SetChild(_propertyName, i));
action(expression);
return(_instance);
}
private Expression DoResolve(ParseContext ec, bool leftValue, bool outAccess)
{
if (!_fieldInfo.IsStatic)
{
if (InstanceExpression == null)
{
//
// This can happen when referencing an instance field using
// a fully qualified type expression: TypeName.InstanceField = xxx
//
// TODO: SimpleName.Error_ObjectRefRequired(ec, loc, GetSignatureForError());
return(null);
}
// Resolve the field's instance expression while flow analysis is turned
// off: when accessing a field "a.b", we must check whether the field
// "a.b" is initialized, not whether the whole struct "a" is initialized.
if (leftValue)
{
var rightSide = outAccess
? EmptyExpression.LValueMemberOutAccess
: EmptyExpression.LValueMemberAccess;
if (InstanceExpression != EmptyExpression.Null)
{
InstanceExpression = InstanceExpression.ResolveLValue(ec, rightSide);
}
}
else
{
const ResolveFlags rf = ResolveFlags.VariableOrValue | ResolveFlags.DisableFlowAnalysis;
if (InstanceExpression != EmptyExpression.Null)
{
InstanceExpression = InstanceExpression.Resolve(ec, rf);
}
}
if (InstanceExpression == null)
{
return(null);
}
}
// TODO: the code above uses some non-standard multi-resolve rules
if (ExpressionClass != ExpressionClass.Invalid)
{
return(this);
}
ExpressionClass = ExpressionClass.Variable;
// If the instance expression is a local variable or parameter.
return(this);
}
/// <summary>
/// Nested Closure to define a child dependency inline
/// </summary>
public TInstance IsSpecial(Action <IInstanceExpression <TChild> > action)
{
var expression =
new InstanceExpression <TChild>(i => _instance.Dependencies.Add(_propertyName, typeof(TChild), i));
action(expression);
return(_instance);
}
public override void EmitCpp(CppEmitContext cec)
{
if (IsStatic)
{
cec.Buf.Write(cec.MakeCppFullTypeName(best_candidate.DeclaringType, false), loc);
}
else
{
InstanceExpression.EmitCpp(cec);
}
cec.Buf.Write("->", "get_", best_candidate.Name, "()", loc);
}
/// <summary>
/// Nested Closure that allows you to add an unlimited number of child Instances
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public TInstance Contains(Action <IInstanceExpression <TElementType> > action)
{
var list = new List <Instance>();
var child = new InstanceExpression <TElementType>(list.Add);
action(child);
_instance.Dependencies.Add(_propertyName, typeof(IEnumerable <TElementType>), new EnumerableInstance(list));
return(_instance);
}
/// <summary>
/// Nested Closure that allows you to add an unlimited number of child Instances
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public TInstance Contains(Action <IInstanceExpression <TElementType> > action)
{
var list = new List <Instance>();
var child = new InstanceExpression <TElementType>(list.Add);
action(child);
_instance.SetCollection(_propertyName, list);
return(_instance);
}
/// <summary>
/// Nested Closure that allows you to add an unlimited number of child Instances
/// </summary>
/// <param name="action"></param>
/// <returns></returns>
public SmartInstance <T> Contains(Action <IInstanceExpression <ARRAY> > action)
{
var list = new List <Instance>();
var child = new InstanceExpression <ARRAY>(list.Add);
action(child);
_instance.SetCollection(_propertyName, list);
return(_instance);
}
internal void Register(
InstanceExpression <TInter> @for,
ConstructorInstance <TImpl, TInter> use,
string instanceName,
DILifeTime lifetime,
Action <DILifeTime, ConstructorInstance <TImpl, TInter> > setLifeTime)
{
this.@for = @for;
this.use = use;
this.instanceName = instanceName;
this.lifetime = lifetime;
this.setLifeTime = setLifeTime;
}
internal override string interpret(Context context)
{
IValue value = new InstanceExpression(id).interpret(context);
if (value is TextValue)
{
return(value.ToString());
}
else
{
throw new SyntaxError("Expected a Text, got a " + value.GetIType().GetTypeName());
}
}
public override void EmitCpp(CppEmitContext cec)
{
if (InstanceExpression != null)
{
InstanceExpression.EmitCpp(cec);
cec.Buf.Write("->");
}
else
{
cec.Buf.Write(DeclaringType.Name, "->", Location);
}
cec.Buf.Write(Name);
}
public override void EmitAssignCpp(CppEmitContext cec, Expression source, bool leave_copy, bool isCompound)
{
if (IsStatic)
{
cec.Buf.Write(cec.MakeCppFullTypeName(best_candidate.DeclaringType, false), loc);
}
else
{
InstanceExpression.EmitCpp(cec);
}
cec.Buf.Write("->", "set_", best_candidate.Name, "(");
source.EmitCpp(cec);
cec.Buf.Write(")", loc);
}
public void parsesMemberExpression()
{
String statement = "p.name";
OTestParser parser = new OTestParser(statement);
IExpression e = parser.parse_instance_expression();
Assert.IsTrue(e is MemberSelector);
MemberSelector me = (MemberSelector)e;
Assert.AreEqual("name", me.getName());
Assert.IsTrue(me.getParent() is InstanceExpression);
InstanceExpression uie = (InstanceExpression)me.getParent();
Assert.AreEqual("p", uie.getName());
}
public override void EmitCpp(CppEmitContext cec)
{
InstanceExpression.EmitCpp(cec);
cec.Buf.Write("[");
bool first = true;
foreach (var arg in arguments)
{
if (!first)
{
cec.Buf.Write(", ");
}
arg.Expr.EmitCpp(cec);
first = false;
}
cec.Buf.Write("]");
}
public override bool Equals(object obj)
{
var fe = obj as FieldExpression;
if (fe == null)
{
return(false);
}
if (_fieldInfo != fe._fieldInfo)
{
return(false);
}
if (InstanceExpression == null || fe.InstanceExpression == null)
{
return(true);
}
return(InstanceExpression.Equals(fe.InstanceExpression));
}
public override MSAst TransformCore(ScriptGenerator generator)
{
return(MSAst.Property(
(InstanceExpression == null) ? null : InstanceExpression.Transform(generator),
PropertyInfo));
}
public override MSAst TransformCore(ScriptGenerator generator)
{
return(MSAst.Field(
InstanceExpression.Transform(generator),
FieldInfo));
}
public object CreateInstance(IContainer container)
{
return(InstanceExpression.Invoke(container));
}
