What causes ": Does not support parse operation." in stanfordnlp/CoreNLP?

Use the lattice-based API: build the lattice hook and call iPossible/lattice parse methods instead of parse(words).

stanfordnlp/CoreNLP · error · UnsupportedOperationException

: Does not support parse operation.

Error message

: Does not support parse operation.

What it means

The inner scorer/hook class in JointParsingModel declares parse(List<? extends HasWord>) only to throw UnsupportedOperationException: this class supports lattice-based decoding through its hooks, not direct sentence parsing. Calling parse on it is an API misuse signaled deliberately.

Solutions

Use the lattice-based API: build the lattice hook and call iPossible/lattice parse methods instead of parse(words).
If you need plain sentence parsing, use the underlying LexicalizedParser (lp) directly rather than this wrapper.
Check the object's concrete type before calling parse in polymorphic code.
Update any pipeline code copied from standard-parser examples to the joint parse-segment workflow.

Example fix

// before
hook.parse(sentence); // UnsupportedOperationException
// after
// use the lattice-aware path
boolean ok = hook.iPossible(latticeHook);
// or parse with the real parser
boolean parsed = lp.parse(sentence);

Defensive patterns

Strategy: type-guard

Validate before calling

// java: detect the unsupported parse path before calling
boolean supportsDirectParse = !(hook instanceof JointParsingModel.GenericLatticeScorer);
if (supportsDirectParse) hook.parse(words);

Type guard

// java
if (hook.getClass().getName().endsWith("GenericLatticeScorer")) {
  // direct parse not supported; use lattice hooks instead
  return;
}

Try / catch

try {
  hook.parse(words);
} catch (UnsupportedOperationException e) {
  if (e.getMessage() != null && e.getMessage().endsWith("Does not support parse operation.")) {
    lp.parse(words); // fall back to the underlying LexicalizedParser
  } else throw e;
}

Prevention

Use the lattice-based API for the joint parse-segment model, not parse(words).
Avoid calling parse() polymorphically on parser wrappers; check the concrete type or interface.
Keep standard-parser examples and joint-model call sites separate.

When it happens

Trigger: Calling parse(words) on the GenericLatticeScorer-backed hook/inner parser object instead of using the lattice interface (iPossible/parse with a lattice hook), or polymorphic code that treats every parser-like object as directly parsable.

Common situations: Generic pipeline code that invokes parse() uniformly on parser adapters; refactors that swapped a full parser for the joint lattice model without updating call sites; examples that use plain LexicalizedParser-style calls against the joint model's inner scorer.

Related errors

AI-assisted analysis of stanfordnlp/CoreNLP@1b7edd19c4 (2026-09-10). Data as JSON: /api/errors/3b037f3d99c2d0a2. Report an issue: GitHub.

Appendix: source

Thrown at src/edu/stanford/nlp/international/arabic/parsesegment/JointParsingModel.java:374

    }

    @Override
    public boolean oPossible(Hook hook) {
      final Hook latticeHook = (Hook) convertItemSpan(new Hook(hook));

      return pparser.oPossible(latticeHook) && dparser.oPossible(hook);
    }

    @Override
    public boolean iPossible(Hook hook) {
      final Hook latticeHook = (Hook) convertItemSpan(new Hook(hook));

      return pparser.iPossible(latticeHook) && dparser.iPossible(hook);
    }

    @Override
    public boolean parse(List<? extends HasWord> words) {
      throw new UnsupportedOperationException(this.getClass().getName() + ": Does not support parse operation.");
    }
  }

}

View on GitHub (pinned to 1b7edd19c4)