Fast check to see if all execution paths contain a return statement.
May spuriously report that a return statement is missing.

@return true if all paths return, converse not necessarily true
174770
private boolean fastAllPathsReturnCheck(ControlFlowGraph<Node> cfg) {
    for (DiGraphEdge<Node, Branch> s : cfg.getImplicitReturn().getInEdges()) {
      Node n = s.getSource().getValue();
      // NOTE(dimvar): it is possible to change ControlFlowAnalysis.java, so
      // that the calls that always throw are treated in the same way as THROW
      // in the CFG. Then, we would not need to use the coding convention here.
      if (!n.isReturn() && !convention.isFunctionCallThatAlwaysThrows(n)) {
        return false;
      }
    }
    return true;
  }
1149467
public boolean hasCache() {
        if (isCache()) {
            return true;
        }
        if (CommonUtils.isNotEmpty(methods)) {
            for (MethodConfig methodConfig : methods.values()) {
                if (CommonUtils.isTrue(methodConfig.getCache())) {
                    return true;
                }
            }
        }
        return false;
    }
278350
private Status executeReturn(Stmt.Return stmt, CallStack frame, EnclosingScope scope) {
		// We know that a return statement can only appear in either a function
		// or method declaration. It cannot appear, for example, in a type
		// declaration. Therefore, the enclosing declaration is a function or
		// method.
		Decl.Callable context = scope.getEnclosingScope(FunctionOrMethodScope.class).getContext();
		Tuple<Decl.Variable> returns = context.getReturns();
		RValue[] values = executeExpressions(stmt.getReturns(), frame);
		for (int i = 0; i != returns.size(); ++i) {
			frame.putLocal(returns.get(i).getName(), values[i]);
		}
		return Status.RETURN;
	}
120928
private boolean isValidReturnValueType(ExpressionTree tree, VisitorState state) {
    Type returnType = null;
    if (tree instanceof MethodInvocationTree) {
      returnType = getReturnType(((JCMethodInvocation) tree).getMethodSelect());
    } else if (tree instanceof MemberReferenceTree) {
      // Get the return type of the target referenced interface
      returnType =
          state.getTypes().findDescriptorType(((JCMemberReference) tree).type).getReturnType();
    }
    if (returnType != null) {
      return capturedTypeAllowed(returnType, state);
    }
    return true;
  }
387835
public boolean isAnyProcessInTreeAlive() {
    for (Integer pId : processTree.keySet()) {
      if (isAlive(pId.toString())) {
        return true;
      }
    }
    return false;
  }
499900
public boolean isNullOnSomePath() {
        int baseKind = getBaseKind();
        if (NCP_EXTRA_BRANCH) {
            // Note: NCP_EXTRA_BRANCH is an experimental feature
            // to see how many false warnings we get when we allow
            // two branches between an explicit null and a
            // a dereference.
            return baseKind == NSP || baseKind == NCP2;
        } else {
            return baseKind == NSP;
        }
    }
1189961
private boolean returnValueNeedsIntCast(Expression arg) {
    ExecutableElement methodElement = TreeUtil.getExecutableElement(arg);
    assert methodElement != null;

    if (arg.getParent() instanceof ExpressionStatement) {
      // Avoid "unused return value" warning.
      return false;
    }

    String methodName = nameTable.getMethodSelector(methodElement);
    if (methodName.equals("hash") && methodElement.getReturnType().getKind() == TypeKind.INT) {
      return true;
    }
    return false;
  }
1221077
public boolean isReverseRoutingPathEmpty() {
        /* If it is never been set, or been set to null, localonly will be null. */
        if (getHdr2().getField(JsHdr2Access.REVERSEROUTINGPATHLOCALONLY) == null) {
            return true;
        }
        /* Otherwise it is possible for it to be 0 length. */
        else if (((byte[]) getHdr2().getField(JsHdr2Access.REVERSEROUTINGPATHLOCALONLY)).length == 0) {
            return true;
        }
        else
            return false;
    }
919930
public boolean hasNext() {
		if(hitLast) {
			return false;
		}
		if(cursor == null) {
			return false;
		}
		if(!gotNext) {
			OperationStatus status;
			// attempt to get the next:
			try {
				if(backward) {
					status = cursor.getPrev(key, value, LockMode.DEFAULT);
				} else {
					status = cursor.getNext(key, value, LockMode.DEFAULT);
				}
				if(status == OperationStatus.SUCCESS) {
					gotNext = true;
				} else {
					close();
				}
			} catch (DatabaseException e) {
				// SLOP: throw a runtime?
				e.printStackTrace();
				close();
			}			
		}
		return gotNext;
	}
452932
def _hasReturnValue(self, node):
        
        returnFound = False
        for subnode in node.body:
            if type(subnode) == node_classes.Return and subnode.value:
                returnFound = True
                break
        return returnFound
416011
def check(self, init_if_missing=False):
        
        for d in self.path_overrides + [self.inputdir]:            
            if os.path.exists(d):
                self.allpaths.append(d)
        if len(self.allpaths) > 0:
            return(True)

        if init_if_missing:
            os.makedirs(self.inputdir)
            return True
764426
static boolean isLeft(final Fastq fastq) {
        checkNotNull(fastq);
        return LEFT.matcher(fastq.getDescription()).matches();
    }
989321
private function backtrack(): bool
    {
        $found = false;

        do {
            $last = \array_pop($this->trace);

            if ($last instanceof Entry) {
                $found = $this->grammar->fetch($last->getRule()) instanceof Alternation;
            } elseif ($last instanceof Escape) {
                $found = $this->grammar->fetch($last->getRule()) instanceof Repetition;
            } elseif ($last instanceof Token) {
                if (! $this->stream->prev()) {
                    return false;
                }
            }
        } while (0 < \count($this->trace) && $found === false);

        if ($found === false) {
            return false;
        }

        $this->todo = $last->getTodo();
        $this->todo[] = new Entry($last->getRule(), $last->getData() + 1);

        return true;
    }
569853
public boolean isSimilar(Execution execution)
    {
        return  execution != null &&
                errors == execution.getErrors() &&
                failures == execution.getFailures() &&
                success == execution.getSuccess() &&
                ignored == execution.getIgnored() &&
                StringUtil.isEquals(executionErrorId, execution.getExecutionErrorId()) &&
                StringUtil.isEquals(results, execution.getResults());
    }
913958
public boolean isSubPath(String[] otherPath) {
        if (path == null || otherPath == null)
            return false;

        if (path.length >= otherPath.length)
            return false;

        for (int i = 0; i < path.length; i++) {
            int result = path[i].compareTo(otherPath[i]);
            if (result != 0)
                return false;
        }

        return true;
    }
184011
public boolean containsProgramPath(String path) {
        return registryMap.containsKey(path) && registryMap.get(path).getProgram() != null;
    }
819515
public boolean getState()
    {
        boolean returnValue = true;
        if (m_objTarget instanceof String)
        {
            String fieldString = this.getString();
            returnValue = m_objTarget.equals(fieldString); // True if == target value
        }
        else
        {
            Object fieldString = this.getData();
            returnValue = m_objTarget.equals(fieldString); // True if == target value
        }
        if (m_bTrueIfMatch)
            return returnValue;
        else
            return !returnValue;
    }