Reports a given node if it's unreachable.
@param {ASTNode} node - A statement node to report.
@returns {void}
509257
function reportIfUnreachable(node) {
            let nextNode = null;

            if (node && currentCodePath.currentSegments.every(isUnreachable)) {

                // Store this statement to distinguish consecutive statements.
                if (range.isEmpty) {
                    range.reset(node);
                    return;
                }

                // Skip if this statement is inside of the current range.
                if (range.contains(node)) {
                    return;
                }

                // Merge if this statement is consecutive to the current range.
                if (range.isConsecutive(node)) {
                    range.merge(node);
                    return;
                }

                nextNode = node;
            }

            /*
             * Report the current range since this statement is reachable or is
             * not consecutive to the current range.
             */
            if (!range.isEmpty) {
                context.report({
                    message: "Unreachable code.",
                    loc: range.location,
                    node: range.startNode
                });
            }

            // Update the current range.
            range.reset(nextNode);
        }
23513
function report(node) {
			var previousToken = sourceCode.getTokenBefore(node);

			context.report(node, previousToken.loc.start, ProblemMessages.noExtraParens);
		}
87889
function(node, content) {
        if (node) {
            this.node = node = $(node);

            if (!content) {
                content = this.readValue(node, this.readOption(node, 'getContent')) || node.attr('href');
            }
        }

        // Show blackout if the element is hidden
        // If it is visible, the blackout count will break
        if (this.blackout && !this.element.is(':shown')) {
            this.blackout.show();
        }

        // Restrict scrolling
        if (this.options.stopScroll) {
            $('body').addClass('no-scroll');
        }

        this.loadContent(content);
    }
236544
function report(node) {
            context.report({
                node,
                message: "Unexpected var, use let or const instead.",

                fix(fixer) {
                    const varToken = sourceCode.getFirstToken(node, { filter: t => t.value === "var" });

                    return canFix(node)
                        ? fixer.replaceText(varToken, "let")
                        : null;
                }
            });
        }
407157
function report(node) {
            const eqToken = node.eqToken
            const keyToken = node.keyToken
            const valueToken = node.valueToken
            context.report({
                node: eqToken,
                messageId: "unexpected",
                fix(fixer) {
                    const range = [
                        keyToken.range[1],
                        valueToken ? valueToken.range[0] : eqToken.range[1],
                    ]
                    return fixer.replaceTextRange(range, "=")
                },
            })
        }
12965
private void handleLeaveEvent(Node node) {
    SwimMember member = members.get(MemberId.from(node.id().id()));
    if (member != null && !member.isActive()) {
      members.remove(member.id());
    }
  }
463341
function report(node) {
            const name = node.key
            context.report({
                node,
                loc: node.loc,
                messageId: "duplicate",
                data: { name },
            })
        }
233712
static <K extends Comparable<K>> void checkNode(Node<K> node) {
        node.checkNode(null, null);
    }
612147
function checkConstantConditionLoopInSet(node) {
            if (loopsInCurrentScope.has(node)) {
                loopsInCurrentScope.delete(node);
                context.report({ node: node.test, messageId: "unexpected" });
            }
        }
881168
function reportUnnecessaryAwait(node) {
            context.report({
                node: context.getSourceCode().getFirstToken(node),
                loc: node.loc,
                message
            });
        }
520863
function (element) {
        if (element === null ||
            !element.tagName ||
            !element.childNodes) {
            throw {
                name: "StropheError",
                message: "Cannot queue non-DOMElement."
            };
        }

        this._data.push(element);
    }
1347759
public void onNodeFinished(final IExecutionNode node) {

        final Description description = descriptionMap.get(Long.valueOf(node.getId()));
        notifyTestFinished(description);

    }
1192835
function(node){
    if ('default' == node.expr) {
      this.buf.push('default:');
    } else {
      this.buf.push('case ' + node.expr + ':');
    }
    if (node.block) {
      this.visit(node.block, node);
      this.buf.push('  break;');
    }
  }
674313
function report(node) {
            context.report({
                node,
                message: "'{{name}}' is assigned to itself.",
                data: {
                    name: sourceCode.getText(node).replace(SPACES, "")
                }
            });
        }
493270
function _reportNode(node) {
  if (node.id) {
    return "id: " + node.id;
  } else if (node.label) {
    return "label: " + node.label;
  } else if (node.value) {
    return "value: " + node.value;
  } else if (node.hasAttributes()) {
    var attrs = "node attributes: ";
    for (var i = node.attributes.length - 1; i >= 0; i--) {
      attrs += node.attributes[i].name + "->" + node.attributes[i].value + ";";
    }
    return attrs;
  } else {
    return "anonymous node";
  }
}
564495
function nodeIsUnscopedBinding(item: Node): boolean {
  const value = getValue(item);
  return value && value.unscoped;
}
1008171
public void unableToSend(String nodeID, LinkedList<byte[]> packets, Throwable cause) {
		if (nodeID != null) {
			executor.execute(() -> {

				// Debug
				if (debug) {
					logger.warn("Unable to send message to \"" + nodeID + "\".", cause);
				}

				// Mark endpoint as offline
				NodeDescriptor node = nodes.get(nodeID);
				boolean disconnected = false;
				if (node != null) {
					node.writeLock.lock();
					try {
						if (node != null && node.markAsOffline()) {

							// Remove actions and listeners
							registry.removeActions(nodeID);
							eventbus.removeListeners(nodeID);
							writer.close(node.nodeID);
							disconnected = true;

						}
					} catch (Exception error) {
						logger.warn("Unable to turn off node!", error);
					} finally {
						node.writeLock.unlock();
					}
				}
				if (node != null && disconnected) {

					// Notify listeners (unexpected disconnection)
					logger.info("Node \"" + nodeID + "\" disconnected.");
					broadcastNodeDisconnected(node.info, true);
				}

				// Send error back to the source
				if (packets != null) {
					FastBuildTree errorMap = null;
					if (cause != null) {

						// Convert to Throwable to MoleculerError
						MoleculerError moleculerError;
						if (cause instanceof MoleculerError) {
							moleculerError = (MoleculerError) cause;
						} else {
							String message = String.valueOf(cause.getMessage());
							message = message.replace('\r', ' ').replace('\n', ' ').trim();
							moleculerError = new MoleculerError(message, cause, "MoleculerError", nodeID, false, 500,
									"UNKNOWN_ERROR");
						}

						// Convert MoleculerError to JSON
						errorMap = new FastBuildTree(8);
						moleculerError.toTree(errorMap);
					}
					for (byte[] packet : packets) {
						try {

							// Remove header
							if (packet != null && packet.length > 6) {
								byte[] copy = new byte[packet.length - 6];
								System.arraycopy(packet, 6, copy, 0, copy.length);

								// Deserialize packet
								Tree message = serializer.read(copy);

								// Get request's unique ID
								String id = message.get("id", (String) null);
								if (id == null || id.isEmpty()) {

									// Not a request
									return;
								}

								// Create response message
								FastBuildTree response = new FastBuildTree(6);
								response.putUnsafe("id", id);
								response.putUnsafe("ver", ServiceBroker.PROTOCOL_VERSION);
								response.putUnsafe("sender", nodeID);
								response.putUnsafe("success", false);
								response.putUnsafe("data", (String) null);
								if (errorMap != null) {
									response.putUnsafe("error", errorMap);
								}
								registry.receiveResponse(response);
							}
						} catch (Exception error) {
							logger.warn("Unable to handle error!", error);
						}
					}
				}
			});
		}
	}