if n.Init != nil {
				r.openScope(n.Tag.Pos())
				defer r.closeScope()
			}
			ast.Walk(r, n.Tag)
		}
		if n.Body != nil {
			r.walkStmts(n.Body.List)
		}

	case *ast.TypeSwitchStmt:
		if n.Init != nil {
			r.openScope(n.Pos())
			defer r.closeScope()
			ast.Walk(r, n.Init)
		}
		r.openScope(n.Assign.Pos())
		defer r.closeScope()
		ast.Walk(r, n.Assign)

        return String.format("and(%s, %s)", left, right);
    }

    @Override
    public boolean calculatePresence(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            if (!left.calculatePresence(consumer) || !right.calculatePresence(consumer)) {
                return false;
            }
        }

    @Override
    public ValueProducer getProducer() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            return new OrElseValueProducer(context, left, right);
        }
    }

    @Override
    public boolean calculatePresence(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            return left.calculatePresence(consumer) || right.calculatePresence(consumer);
        }

        try (EvaluationContext.ScopeContext context = openScope()) {
            return backingProvider(context, consumer).calculatePresence(consumer);
        }
    }

    @Override
    protected Value<? extends S> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            Value<? extends T> value = provider.calculateValue(consumer);

        try (EvaluationContext.ScopeContext context = openScope()) {
            beforeReadNoProducer(context, consumer);
            return doCalculateValue(context, consumer);
        }
    }

    @Override
    protected Value<? extends T> calculateOwnValue(ValueConsumer consumer) {
        try (EvaluationContext.ScopeContext context = openScope()) {
            beforeRead(context, consumer);

    public ValueProducer getProducer() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            return new OrElseValueProducer(context, provider);
        }
    }

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            ExecutionTimeValue<? extends T> value = provider.calculateExecutionTimeValue();

    @Override
    public ValueProducer getProducer() {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            return provider.getProducer();
        }
    }

    @Override
    public ExecutionTimeValue<? extends T> calculateExecutionTimeValue() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            ExecutionTimeValue<? extends T> value = provider.calculateExecutionTimeValue();

    @Override
    public ValueProducer getProducer() {
        try (EvaluationContext.ScopeContext ignored = openScope()) {
            return provider.getProducer();
        }
    }

    @Override
    public ExecutionTimeValue<? extends OUT> calculateExecutionTimeValue() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            ExecutionTimeValue<? extends IN> value = provider.calculateExecutionTimeValue();

        try (EvaluationContext.ScopeContext ignored = openScope()) {
            return provider.calculatePresence(consumer);
        }
    }

    @Override
    public ExecutionTimeValue<? extends OUT> calculateExecutionTimeValue() {
        try (EvaluationContext.ScopeContext context = openScope()) {
            ExecutionTimeValue<? extends IN> value = provider.calculateExecutionTimeValue();

			}
		default:
			check.errorf(s, InvalidSyntaxTree, "branch statement: %s", s.Tok)
		}

	case *ast.BlockStmt:
		check.openScope(s, "block")
		defer check.closeScope()

		check.stmtList(inner, s.List)

	case *ast.IfStmt:
		check.openScope(s, "if")
		defer check.closeScope()

		check.simpleStmt(s.Init)
		var x operand
		check.expr(nil, &x, s.Cond)