protected override IEnumerator ExecuteStep() { InternalBounds = new List <BoundingBox>(); foreach (var metaSelectionSet in TargetExpression.ResolveExpression(ChainView.Instance.Chain.RootBoundingBoxes)) { var foundSelectable = metaSelectionSet.GetComponent <MetaSelectionSet>(); if (foundSelectable == null) { continue; } var selection = new MetaSelectionMode(); selection.Selectable = foundSelectable; selection.OperationToPerform = MetaSelectionOperation; var iterator = selection.ApplyMode( MetaSelectionSet.GetLocalSelectables(BoundsToSelect.Bounds, foundSelectable) ); while (iterator.MoveNext()) { yield return(null); } } Router.FireEvent(EndEventName); yield return(null); }
public override IEnumerable <BindingParserNode> EnumerateNodes() { return (base.EnumerateNodes() .Concat(TargetExpression.EnumerateNodes()) .Concat(ArgumentExpressions.SelectMany(a => a.EnumerateNodes()))); }
public override IEnumerable <BindingParserNode> EnumerateNodes() { return (base.EnumerateNodes() .Concat(TargetExpression.EnumerateNodes()) .Concat(MemberNameExpression.EnumerateNodes())); }
public TargetExpression ReadTarget() { TargetExpression exp = null; var token = Reader.DiscardToken(TokenType.Target); exp = new TargetExpression(token.Value.Replace("target ", "")); return(exp); }
public override void CodeGen(CodeBuilder builder) { TargetExpression.CodeGen(builder); builder.AppendToken("="); Expression.CodeGen(builder); builder.EndOfStatement(); }
/// <summary> /// Serializes into the given writer. /// </summary> protected override void DoSerialize(BuildXLWriter writer) { TargetExpression.Serialize(writer); writer.Write(TargetQualifierSpaceId); writer.Write(ShouldUseDefaultsOnCoercion); // Force computation of line and column. When deserializing, // the wrong file map will be available. ReferencedLocation.DoSerialize(writer, forceLineAndColumn: true); }
public override void RewriteChildren(TargetExpression targetExpression) { BoundField /*?*/ boundField; if (this.fieldForCapturedLocalOrParameter.TryGetValue(targetExpression.Definition, out boundField)) { targetExpression.Instance = new ThisReference(); targetExpression.Definition = iteratorClosure.GetReferenceOfFieldUsedByPeers(boundField.Field); targetExpression.Type = boundField.Type; return; } base.RewriteChildren(targetExpression); }
/// <inheritdoc /> protected override EvaluationResult DoEval(Context context, ModuleLiteral env, EvaluationStackFrame frame) { var moduleCandidate = TargetExpression.Eval(context, env, frame); if (moduleCandidate.IsErrorValue || moduleCandidate.IsUndefined) { return(moduleCandidate); } // Qualifier type coercion could happen on both namespaces and files when importFrom is used. var module = moduleCandidate.Value as ModuleLiteral; // Moving Assert into the if block to avoid relatively expensive message computation for non-error case. if (module == null) { Contract.Assert( false, I($"TargetExpression '{TargetExpression.ToDisplayString(context)}' should produce 'ModuleLiteral' but produced '{moduleCandidate.Value.GetType()}'")); } var pathTable = context.FrontEndContext.PathTable; // TODO: Consider if it is possible to use QualifierUtilities.CoerceQualifierValue instead. QualifierValue oldQualifierValue = module.Qualifier; if ( !oldQualifierValue.TryCoerce( TargetQualifierSpaceId, context.FrontEndContext.QualifierTable, context.QualifierValueCache, pathTable, context.FrontEndContext.StringTable, context.FrontEndContext.LoggingContext, out QualifierValue coercedQualifier, Location, ShouldUseDefaultsOnCoercion, context.LastActiveUsedPath)) { context.Errors.ReportQualifierCannotBeCoarcedToQualifierSpaceWithProvenance( oldQualifierValue.QualifierId, TargetQualifierSpaceId, ReferencedLocation.AsLoggingLocation(), Location.AsLoggingLocation(env, context)); return(EvaluationResult.Error); } return(EvaluationResult.Create(module.Instantiate(context.ModuleRegistry, coercedQualifier))); }
/// <inheritdoc /> public override string ToDebugString() { return(I($"coerceQualifier({TargetExpression.ToDebugString()}, {TargetQualifierSpaceId})")); }
public override string ToDisplayString() => $"{TargetExpression.ToDisplayString()}.{MemberNameExpression.ToDisplayString()}";
public VccPrefixIncrement(TargetExpression target, ISourceLocation sourceLocation) : base(target, sourceLocation) { }
public override string ToDisplayString() => $"{TargetExpression.ToDisplayString()}[{ArrayIndexExpression.ToDisplayString()}]";
public SmallBasicAssignment(TargetExpression target, Expression source, ISourceLocation sourceLocation) : base(target, source, sourceLocation) { }
private Expression ParseAssignmentExpression(Expression operand1, TokenSet followers) //^ requires Parser.InfixOperators[this.currentToken]; //^ requires this.currentToken != Token.Conditional; //^ ensures followers[this.currentToken] || this.currentToken == Token.EndOfFile; { switch (this.currentToken) { case Token.PlusAssign: case Token.Assign: case Token.BitwiseAndAssign: case Token.BitwiseOrAssign: case Token.BitwiseXorAssign: case Token.DivideAssign: case Token.LeftShiftAssign: case Token.MultiplyAssign: case Token.RemainderAssign: case Token.RightShiftAssign: case Token.SubtractAssign: SourceLocationBuilder slb = new SourceLocationBuilder(operand1.SourceLocation); Token operatorToken = this.currentToken; this.GetNextToken(); TargetExpression target = new TargetExpression(operand1); Expression operand2 = this.ParseExpression(followers); slb.UpdateToSpan(operand2.SourceLocation); //^ assume followers[this.currentToken] || this.currentToken == Token.EndOfFile; switch (operatorToken) { case Token.PlusAssign: return new AdditionAssignment(target, operand2, slb); case Token.BitwiseAndAssign: return new BitwiseAndAssignment(target, operand2, slb); case Token.BitwiseOrAssign: return new BitwiseOrAssignment(target, operand2, slb); case Token.BitwiseXorAssign: return new ExclusiveOrAssignment(target, operand2, slb); case Token.DivideAssign: return new DivisionAssignment(target, operand2, slb); case Token.LeftShiftAssign: return new LeftShiftAssignment(target, operand2, slb); case Token.MultiplyAssign: return new MultiplicationAssignment(target, operand2, slb); case Token.RemainderAssign: return new ModulusAssignment(target, operand2, slb); case Token.RightShiftAssign: return new RightShiftAssignment(target, operand2, slb); case Token.SubtractAssign: return new SubtractionAssignment(target, operand2, slb); default: return new Assignment(target, operand2, slb); } default: operand1 = this.ParseBinaryExpression(operand1, followers|Token.Conditional); if (this.currentToken == Token.Conditional) return this.ParseConditional(operand1, followers); //^ assume followers[this.currentToken] || this.currentToken == Token.EndOfFile; return operand1; } }
/// <summary> /// Allocates an expression that adds or concatenates the value of the left operand with the value of the right operand. /// The result of the expression is assigned to the left operand, which must be a target expression. /// Both operands must be primitives types. /// </summary> /// <param name="leftOperand">The left operand and target of the assignment.</param> /// <param name="rightOperand">The right operand.</param> /// <param name="sourceLocation">The source location of the operation.</param> public VccAdditionAssignment(TargetExpression leftOperand, Expression rightOperand, ISourceLocation sourceLocation) : base(leftOperand, rightOperand, sourceLocation) { }
public VccPostfixDecrement(TargetExpression target, ISourceLocation sourceLocation) : base(target, sourceLocation) { }
public VccInitializerAssignment(TargetExpression leftOperand, VccInitializerWithDesignators rightOperand, ISourceLocation sourceLocation) : base(leftOperand, rightOperand, sourceLocation) { }
public override string ToDisplayString() => $"{TargetExpression.ToDisplayString()}({string.Join(", ", ArgumentExpressions.Select(e => e.ToDisplayString()))})";
internal void TransferTo(StackOfLocals targetStack, List <IStatement> list) { Contract.Requires(targetStack != null); Contract.Requires(list != null); Contract.Requires(Contract.ForAll(list, x => x != null)); for (int i = 0; i <= this.top && i <= targetStack.top; i++) { Contract.Assert(this.top >= 0); Contract.Assert(this.top < this.elements.Length); var sourceLocal = this.elements[i]; Contract.Assert(targetStack.top >= 0); Contract.Assume(targetStack.elements != null); Contract.Assume(targetStack.top < targetStack.elements.Length); var targetLocal = targetStack.elements[i]; Contract.Assume(targetLocal != null); if (sourceLocal == targetLocal) { continue; } if (targetLocal.turnIntoPopValueExpression) { sourceLocal.turnIntoPopValueExpression = true; } else if (sourceLocal.turnIntoPopValueExpression) { targetLocal.turnIntoPopValueExpression = true; } else { Contract.Assume(this.body.numberOfReferences != null); this.body.numberOfReferences[sourceLocal]++; Contract.Assume(this.body.numberOfAssignments != null); this.body.numberOfAssignments[targetLocal]++; var targetType = targetLocal.Type; var sourceType = sourceLocal.Type; var mergedType = TypeHelper.MergedType(TypeHelper.StackType(targetType), TypeHelper.StackType(sourceType)); if (targetType != mergedType && !(targetType.TypeCode == PrimitiveTypeCode.Boolean && mergedType.TypeCode == PrimitiveTypeCode.Int32)) { targetLocal.Type = mergedType; targetType = mergedType; if (targetType is Dummy || sourceType is Dummy) { targetLocal.isPolymorphic = true; } } var target = new TargetExpression() { Definition = targetLocal, Type = targetType }; var source = new BoundExpression() { Definition = sourceLocal, Type = sourceType }; var assigment = new Assignment() { Target = target, Source = source, Type = targetType }; list.Add(new ExpressionStatement() { Expression = assigment }); } } //Contract.Assume(this.top < 0 || Contract.ForAll(0, this.top+1, i => this.elements[i] != null)); }
public VccOutArgument(TargetExpression expression, ISourceLocation sourceLocation) : base(expression, sourceLocation) { }