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)); }