Restricts the variables in the BDD {@code r} to constants true or false.  The restriction is submitted in the BDD
{@code var}.
@param r   the BDD to be restricted
@param var the variable mapping as a BDD
@return the restricted BDD
548849
public int restrict(final int r, final int var) {
    final int res;
    if (var < 2)
      return r;
    varset2svartable(var);
    initRef();
    res = restrictRec(r, (var << 3) | CACHEID_RESTRICT);
    return res;
  }
1310328
public final Set<Variable> vars() {
        if (vars == null) {
            ImmutableSet.Builder<Variable> builder = ImmutableSet.<Variable>builder().add(start());
            Variable end = end();
            if (end != null) builder.add(end);
            builder.addAll(otherVars());
            vars = builder.build();
        }

        return vars;
    }
899909
@Override
    public InjectiveVar2VarSubstitution generateNotConflictingRenaming(VariableGenerator variableGenerator,
                                                                       ImmutableSet<Variable> variables) {
        ImmutableMap<Variable, Variable> newMap = variables.stream()
                .map(v -> new AbstractMap.SimpleEntry<>(v, generateNonConflictingVariable(v, variableGenerator, variables)))
                .filter(pair -> ! pair.getKey().equals(pair.getValue()))
                .collect(ImmutableCollectors.toMap());

        return getInjectiveVar2VarSubstitution(newMap);
    }
375401
public String getVariableQualifiedName(VariableElement var) {
    String shortName = getVariableShortName(var);
    if (ElementUtil.isGlobalVar(var)) {
      String className = getFullName(ElementUtil.getDeclaringClass(var));
      if (ElementUtil.isEnumConstant(var)) {
        // Enums are declared in an array, so we use a macro to shorten the
        // array access expression.
        return "JreEnum(" + className + ", " + shortName + ")";
      }
      return className + '_' + shortName;
    }
    return shortName;
  }
1165253
private SemanticType checkVariable(Expr.VariableAccess expr, Environment environment) {
		Decl.Variable var = expr.getVariableDeclaration();
		return environment.getType(var);
	}
1370443
public void setR(double r)
    {
        if(Double.isNaN(r) || Double.isInfinite(r) || r <= 0)
            throw new IllegalArgumentException("r must be a postive constant, not " + r);
        this.r = r;
    }
322815
public boolean isGlobalVariable(@Nullable final String variableName) {
    boolean result = false;
    if (variableName != null) {
      final String normalized = PreprocessorUtils.normalizeVariableName(variableName);
      result = this.globalVarTable.containsKey(normalized) || mapVariableNameToSpecialVarProcessor.containsKey(normalized);
    }
    return result;
  }
380467
public static TypeVariableConstraint withVariadicBound(String name, String variadicBound)
    {
        return new TypeVariableConstraint(name, false, false, variadicBound);
    }
315779
public static Tuple<Decl.Variable> determineModifiedVariables(Stmt.Block block) {
		HashSet<Decl.Variable> modified = new HashSet<>();
		determineModifiedVariables(block, modified);
		return new Tuple<>(modified);
	}
954244
public boolean matches( VarNamePattern varName)
    {
    boolean matched =
      // Variable name defined?
      varName != null

      // Variable name and this pattern both (non-)empty?
      && (varName.varNamePath_ == null) == (varNamePath_ == null)

      // Variable name identifies single variable of depth no less than this pattern?
      && !varName.wildcard_
      && varName.minDepth_ >= minDepth_;

    if( matched && varNamePath_ != null)
      {
      // Variable name matches this pattern up to wildcard?
      int i;
      for( i = 0;

           i < minDepth_
             && (matched = varName.varNamePath_[i].equals( varNamePath_[i]));

           i++);

      if( matched)
        {
        int membersLeft = varName.minDepth_ - minDepth_;

        String wildcardType =
          !wildcard_
          ? null
          : varNamePath_[i];
          
        matched =
          // No wildcard to match?
          wildcardType == null
          ? (membersLeft == 0)

          // This variable is a matching child?
          : ((membersLeft == 1 && wildcardType.equals( ALL_CHILDREN))
             ||
             // This variable is a matching descendant?
             wildcardType.equals( ALL_DESCENDANTS));
        }
      }
      
    return matched;
    }
650640
@Override
    public boolean isVariableNullable(IntermediateQuery query, Variable variable) {
        if (getVariables().contains(variable))
            return false;
        else
            throw new IllegalArgumentException("The variable" + variable + " is not projected by " + this);
    }
1334848
private static Node varToAssign(Node var) {
    Node assign =
        IR.assign(var.getFirstChild().cloneNode(), var.getFirstChild().removeFirstChild());
    return IR.exprResult(assign).useSourceInfoIfMissingFromForTree(var);
  }
707966
function checkVariable(variable) {
			getModifyingReferences(variable.references).forEach(function(reference) {
				context.report(
					reference.identifier,
					ProblemMessages.noConstantAssign,
					{
						name: reference.identifier.name
					});
			});
		}
668038
public static Expr1ViewItem<Boolean> expr( String exprId, Variable<Boolean> var ) {
        return new Expr1ViewItemImpl<>( exprId, var, new Predicate1.Impl<>( x -> x != null ? x : false ) );
    }
301968
public VarValueDef getBinding( VarDef var)
    {
    VarBindingDef binding = bindings_.get( var);
    return
      binding == null
      ? null
      : binding.getValueDef();
    }
797313
public final void variableDeclaratorId() throws RecognitionException {
		int variableDeclaratorId_StartIndex = input.index();

		try {
			if ( state.backtracking>0 && alreadyParsedRule(input, 43) ) { return; }

			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:491:5: ( Identifier ( '[' ']' )* )
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:491:7: Identifier ( '[' ']' )*
			{
			match(input,Identifier,FOLLOW_Identifier_in_variableDeclaratorId1483); if (state.failed) return;
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:491:18: ( '[' ']' )*
			loop59:
			while (true) {
				int alt59=2;
				int LA59_0 = input.LA(1);
				if ( (LA59_0==59) ) {
					alt59=1;
				}

				switch (alt59) {
				case 1 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:491:19: '[' ']'
					{
					match(input,59,FOLLOW_59_in_variableDeclaratorId1486); if (state.failed) return;
					match(input,60,FOLLOW_60_in_variableDeclaratorId1488); if (state.failed) return;
					}
					break;

				default :
					break loop59;
				}
			}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			if ( state.backtracking>0 ) { memoize(input, 43, variableDeclaratorId_StartIndex); }

		}
	}
730361
@NonNull
    public final ItemBinding<T> set(int variableId, @LayoutRes int layoutRes) {
        this.variableId = variableId;
        this.layoutRes = layoutRes;
        return this;
    }