How to use the stylelint.utils.report function in stylelint

root.walkAtRules(decl => {
      if (decl.name !== "function") {
        return;
      }

      // Stripping the function of its arguments
      const funcName = decl.params.replace(/(\s*?)\((?:\s|\S)*\)/g, "");

      if (regexpPattern.test(funcName)) {
        return;
      }

      utils.report({
        message: messages.expected,
        node: decl,
        result,
        ruleName
      });
    });
  };

return;
      }

      // "ignore" options
      if (
        optionsHaveIgnored(secondaryOptions, "local") &&
        decl.parent.type !== "root"
      ) {
        return;
      }

      if (decl.value.toLowerCase().includes("!default")) {
        return;
      }

      utils.report({
        message: messages.expected(decl.prop),
        node: decl,
        result,
        ruleName
      });
    });
  };

return;
      }

      if (optionsMatches(options, "ignoreProperties", prop)) {
        return;
      }

      if (props.indexOf(prop.toLowerCase()) !== -1) {
        return;
      }

      if (/^-styled-mixin\d+/.test(prop.toLowerCase())) {
        return;
      }

      utils.report({
        message: messages.rejected(prop),
        node: decl,
        result,
        ruleName
      });
    });
  };

return;
      }

      if (isCustomProperty(prop)) {
        return;
      }

      if (optionsMatches(options, "ignoreProperties", prop)) {
        return;
      }

      if (props.indexOf(prop.toLowerCase()) !== -1) {
        return;
      }

      utils.report({
        message: messages.rejected(prop),
        node: decl,
        result,
        ruleName
      });
    });
  };

root.walkDecls(/^font-weight$/i, decl => {
      if (acceptedWeights.indexOf(decl.value) > -1) {
        return;
      }

      const weightValueOffset = decl.value.indexOf(decl.value);
      const index = declarationValueIndex(decl) + weightValueOffset;

      utils.report({
        message: messages.rejected(decl.value),
        node: decl,
        result,
        ruleName,
        index
      });
    });
  };

results.filter(resultItem => !!resultItem).forEach(({
    node,
    url,
    bytesSize
  }) => {
    if (bytesSize < limitBytes) {
      utils.report({ message: messages.expected(url), node, result, ruleName });
    }
  });
}

function complain(node, message, index, fixValue) {
    if (context.fix) {
      node.next().raws.before = fixValue;

      return;
    }

    utils.report({
      result,
      ruleName,
      node,
      message,
      index
    });
  }

nestedGroups[namespace].forEach(group => {
          utils.report({
            message: messages.expected(namespace),
            node: group,
            result,
            ruleName
          });
        });
      });

const symbol = string.substring(startIndex, endIndex + 1);
  let newLineBefore = false;

  let index = startIndex - 1;

  while (index && isWhitespace(string[index])) {
    if (string[index] === "\n") {
      newLineBefore = true;
      break;
    }

    index--;
  }

  if (newLineBefore) {
    utils.report({
      ruleName,
      result,
      node,
      message: messages.rejected(symbol),
      index: endIndex + globalIndex
    });
  }
}

decl.parent.type === "atrule" &&
        secondaryOptions &&
        secondaryOptions.ignoreInsideAtRules &&
        secondaryOptions.ignoreInsideAtRules.includes(decl.parent.name);

      if (
        !isVar ||
        isInsideIgnoredAtRule ||
        isInsideIgnoredNestedAtRule ||
        isInsideIgnoredSpecifiedAtRule
      ) {
        return;
      }

      if (vars[decl.prop]) {
        utils.report({
          message: messages.rejected(decl.prop),
          node: decl,
          result,
          ruleName
        });
      }

      vars[decl.prop] = true;
    });
  };