True if the given Node is the GETPROP in a statement like `some.q.name;`

<p>Such do-nothing statements often have JSDoc on them and are intended to declare the
qualified name.

@param node any Node, or even null
490362
private static boolean isQnameDeclarationWithoutAssignment(@Nullable Node node) {
    return node != null && node.isGetProp() && node.getParent().isExprResult();
  }
638656
function(node){
			var classes = this.getUfClassNames(node);
			if(classes.root && classes.root.length > 0){
				return true;
			}else{
				return false;
			}
		}
1067598
public static boolean isElement(Node node) {
		return (null == node) ? false : Node.ELEMENT_NODE == node.getNodeType();
	}
226764
function(node){
    var nodeName = node.nodeName;
    while ((node = node.previousSibling)) if (node.nodeName == nodeName) return false;
    return true;
  }
204159
public boolean isAncestor(XMLNode node) {
		return node == parent || (parent != null && parent.isAncestor(node));
	}
246599
public boolean isPreviousThan(Node node) {
        if (getEndLine() < node.getBeginLine()) {
            return true;
        } else if ((getEndLine() == node.getBeginLine()) && (getEndColumn() <= node.getBeginColumn())) {
            return true;
        }
        return false;
    }
723098
private static NodeCondition getNodeReadyCondition(Node node) {
    Utils.checkNotNull(node, "Node can't be null.");

    if (node.getStatus() == null || node.getStatus().getConditions() == null) {
      return null;
    }

    for (NodeCondition condition : node.getStatus().getConditions()) {
      if (NODE_READY.equals(condition.getType())) {
        return condition;
      }
    }
    return null;
  }
450721
public static boolean hasMixin(final Node node) {
        try {
            return node.isNodeType(FEDORA_WEBAC_ACL);
        } catch (final RepositoryException e) {
            throw new RepositoryRuntimeException(e);
        }
    }
519741
function hasProperty(node, name) {
  var props
  var value

  if (!node || !name || typeof node !== 'object' || node.type !== 'element') {
    return false
  }

  props = node.properties
  value = props && own.call(props, name) && props[name]

  return value !== null && value !== undefined && value !== false
}
522578
public static VariableElement getVariableElement(Expression node) {
    node = trimParentheses(node);
    switch (node.getKind()) {
      case FIELD_ACCESS:
        return ((FieldAccess) node).getVariableElement();
      case SUPER_FIELD_ACCESS:
        return ((SuperFieldAccess) node).getVariableElement();
      case QUALIFIED_NAME:
      case SIMPLE_NAME:
        return getVariableElement((Name) node);
      default:
        return null;
    }
  }
623589
private static boolean isClassFieldDeclaration(Node node) {
    return node.getParent().isScript()
        && node.isVar()
        && (!node.getFirstChild().hasChildren()
            || (node.getFirstFirstChild() != null
                && NodeUtil.isLiteralValue(
                    node.getFirstFirstChild(), false /* includeFunctions */)));
  }
127385
public static boolean hasPossibleStaticProperty(ClassNode cNode, String methodName) {
        // assume explicit static method call checked first so we can assume a simple check here
        if (!methodName.startsWith("get") && !methodName.startsWith("is")) {
            return false;
        }
        String propName = getPropNameForAccessor(methodName);
        PropertyNode pNode = getStaticProperty(cNode, propName);
        return pNode != null && (methodName.startsWith("get") || boolean_TYPE.equals(pNode.getType()));
    }
481224
private boolean isValidationMatcherExpression(Node node) {
        switch (node.getNodeType()) {
            case Node.ELEMENT_NODE:
                return node.getFirstChild() != null &&
                StringUtils.hasText(node.getFirstChild().getNodeValue()) &&
                ValidationMatcherUtils.isValidationMatcherExpression(node.getFirstChild().getNodeValue().trim());

            case Node.ATTRIBUTE_NODE:
                return StringUtils.hasText(node.getNodeValue()) &&
                ValidationMatcherUtils.isValidationMatcherExpression(node.getNodeValue().trim());

            default: return false; //validation matchers makes no sense
        }
    }
433534
static boolean readBoolean(Node node)
    {
        if (node == null)
        {
            throw new XmlException(
                "Tried to read boolean value from null node");
        }
        String value = node.getFirstChild().getNodeValue();
        return Boolean.parseBoolean(value);
    }
205443
protected String getNonNamespacedNodeName(Node node) {
        String name = node.getLocalName();
        if (name == null) {
            return node.getNodeName();
        }
        return name;
    }
812833
@CheckForNull
    public Node getNode(String name) {
        return name == null ? null : nodes.get(name);
    }
247562
protected static String getAttribute(Node node, String name, boolean required) {
        NamedNodeMap attributes = node.getAttributes();
        Node idNode = attributes.getNamedItem(name);
        if (idNode == null) {
            if (required) {
                throw new IllegalArgumentException(toPath(node) + " has no " + name + " attribute");
            }
            else {
                return "";
            }
        }
        else {
            String value = idNode.getNodeValue();
            if (value == null) {
                return "";
            }
            return value;
        }
    }