Markdown, sections, styles and lots more.

1 files changed, 1031 insertions, 0 deletions

diff --git a/src/Markdown/GeneratedParserUtilBase.java b/src/Markdown/GeneratedParserUtilBase.java
new file mode 100644
index 00000000..9dd999b5
--- /dev/null
+++ b/src/Markdown/GeneratedParserUtilBase.java
@@ -0,0 +1,1031 @@
+/*
+ * Copyright 2011-2014 Gregory Shrago
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.dokka.Markdown;
+
+import com.intellij.lang.*;
+import com.intellij.lang.impl.PsiBuilderAdapter;
+import com.intellij.lang.impl.PsiBuilderImpl;
+import com.intellij.lexer.Lexer;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.util.Comparing;
+import com.intellij.openapi.util.Key;
+import com.intellij.openapi.util.Pair;
+import com.intellij.openapi.util.text.StringHash;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiReference;
+import com.intellij.psi.TokenType;
+import com.intellij.psi.impl.source.resolve.FileContextUtil;
+import com.intellij.psi.impl.source.tree.CompositePsiElement;
+import com.intellij.psi.tree.ICompositeElementType;
+import com.intellij.psi.tree.IElementType;
+import com.intellij.psi.tree.TokenSet;
+import com.intellij.util.Function;
+import com.intellij.util.PairProcessor;
+import com.intellij.util.containers.ContainerUtil;
+import com.intellij.util.containers.LimitedPool;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedList;
+
+/**
+ * @author gregsh
+ */
+public class GeneratedParserUtilBase {
+
+  private static final Logger LOG = Logger.getInstance("org.intellij.grammar.parser.GeneratedParserUtilBase");
+
+  private static final int MAX_RECURSION_LEVEL = 1000;
+  private static final int MAX_VARIANTS_SIZE = 10000;
+  private static final int MAX_VARIANTS_TO_DISPLAY = 50;
+
+  private static final int INITIAL_VARIANTS_SIZE = 1000;
+  private static final int VARIANTS_POOL_SIZE = 10000;
+  private static final int FRAMES_POOL_SIZE = 500;
+
+  public static final IElementType DUMMY_BLOCK = new DummyBlockElementType();
+
+  public interface Parser {
+    boolean parse(PsiBuilder builder, int level);
+  }
+
+  public static final Parser TOKEN_ADVANCER = new Parser() {
+    @Override
+    public boolean parse(PsiBuilder builder, int level) {
+      if (builder.eof()) return false;
+      builder.advanceLexer();
+      return true;
+    }
+  };
+
+  public static final Parser TRUE_CONDITION = new Parser() {
+    @Override
+    public boolean parse(PsiBuilder builder, int level) {
+      return true;
+    }
+  };
+
+  public static boolean eof(PsiBuilder builder_, int level_) {
+    return builder_.eof();
+  }
+
+  public static int current_position_(PsiBuilder builder_) {
+    return builder_.rawTokenIndex();
+  }
+
+  public static boolean recursion_guard_(PsiBuilder builder_, int level_, String funcName_) {
+    if (level_ > MAX_RECURSION_LEVEL) {
+      builder_.error("Maximum recursion level (" + MAX_RECURSION_LEVEL + ") reached in '" + funcName_ + "'");
+      return false;
+    }
+    return true;
+  }
+
+  public static boolean empty_element_parsed_guard_(PsiBuilder builder_, String funcName_, int prev_position_) {
+    if (prev_position_ == current_position_(builder_)) {
+      builder_.error("Empty element parsed in '" + funcName_ + "' at offset " + builder_.getCurrentOffset());
+      return false;
+    }
+    return true;
+  }
+
+  public static boolean invalid_left_marker_guard_(PsiBuilder builder_, PsiBuilder.Marker marker_, String funcName_) {
+    //builder_.error("Invalid left marker encountered in " + funcName_ +" at offset " + builder_.getCurrentOffset());
+    boolean goodMarker = marker_ != null; // && ((LighterASTNode)marker_).getTokenType() != TokenType.ERROR_ELEMENT;
+    if (!goodMarker) return false;
+    ErrorState state = ErrorState.get(builder_);
+
+    return !state.frameStack.isEmpty();
+  }
+
+  public static TokenSet create_token_set_(IElementType... tokenTypes_) {
+    return TokenSet.create(tokenTypes_);
+  }
+
+  private static boolean consumeTokens(PsiBuilder builder_, boolean smart, int pin, IElementType... tokens) {
+    ErrorState state = ErrorState.get(builder_);
+    if (state.completionState != null && state.predicateCount == 0) {
+      addCompletionVariant(builder_, state.completionState, tokens);
+    }
+    // suppress single token completion
+    CompletionState completionState = state.completionState;
+    state.completionState = null;
+    boolean result_ = true;
+    boolean pinned_ = false;
+    for (int i = 0, tokensLength = tokens.length; i < tokensLength; i++) {
+      if (pin > 0 && i == pin) pinned_ = result_;
+      if (result_ || pinned_) {
+        boolean fast = smart && i == 0;
+        if (!(fast ? consumeTokenFast(builder_, tokens[i]) : consumeToken(builder_, tokens[i]))) {
+          result_ = false;
+          if (pin < 0 || pinned_) report_error_(builder_, state, false);
+        }
+      }
+    }
+    state.completionState = completionState;
+    return pinned_ || result_;
+  }
+
+  public static boolean consumeTokens(PsiBuilder builder_, int pin_, IElementType... token) {
+    return consumeTokens(builder_, false, pin_, token);
+  }
+
+  public static boolean consumeTokensSmart(PsiBuilder builder_, int pin_, IElementType... token) {
+    return consumeTokens(builder_, true, pin_, token);
+  }
+
+  public static boolean parseTokens(PsiBuilder builder_, int pin_, IElementType... tokens) {
+    return parseTokens(builder_, false, pin_, tokens);
+  }
+
+  public static boolean parseTokensSmart(PsiBuilder builder_, int pin_, IElementType... tokens) {
+    return parseTokens(builder_, true, pin_, tokens);
+  }
+
+  public static boolean parseTokens(PsiBuilder builder_, boolean smart, int pin_, IElementType... tokens) {
+    PsiBuilder.Marker marker_ = builder_.mark();
+    boolean result_ = consumeTokens(builder_, smart, pin_, tokens);
+    if (!result_) {
+      marker_.rollbackTo();
+    }
+    else {
+      marker_.drop();
+    }
+    return result_;
+  }
+
+  public static boolean consumeTokenSmart(PsiBuilder builder_, IElementType token) {
+    addCompletionVariantSmart(builder_, token);
+    return consumeTokenFast(builder_, token);
+  }
+
+  public static boolean consumeTokenSmart(PsiBuilder builder_, String token) {
+    addCompletionVariantSmart(builder_, token);
+    return consumeTokenFast(builder_, token);
+  }
+
+  public static boolean consumeToken(PsiBuilder builder_, IElementType token) {
+    addVariantSmart(builder_, token, true);
+    if (nextTokenIsFast(builder_, token)) {
+      builder_.advanceLexer();
+      return true;
+    }
+    return false;
+  }
+
+  public static boolean consumeTokenFast(PsiBuilder builder_, IElementType token) {
+    if (nextTokenIsFast(builder_, token)) {
+      builder_.advanceLexer();
+      return true;
+    }
+    return false;
+  }
+
+  public static boolean consumeToken(PsiBuilder builder_, String text) {
+    return consumeToken(builder_, text, ErrorState.get(builder_).caseSensitive);
+  }
+
+  public static boolean consumeToken(PsiBuilder builder_, String text, boolean caseSensitive) {
+    addVariantSmart(builder_, text, true);
+    int count = nextTokenIsFast(builder_, text, caseSensitive);
+    if (count > 0) {
+      while (count-- > 0) builder_.advanceLexer();
+      return true;
+    }
+    return false;
+  }
+
+  public static boolean consumeTokenFast(PsiBuilder builder_, String text) {
+    int count = nextTokenIsFast(builder_, text, ErrorState.get(builder_).caseSensitive);
+    if (count > 0) {
+      while (count-- > 0) builder_.advanceLexer();
+      return true;
+    }
+    return false;
+  }
+
+  public static boolean nextTokenIsFast(PsiBuilder builder_, IElementType token) {
+    return builder_.getTokenType() == token;
+  }
+
+  public static boolean nextTokenIsFast(PsiBuilder builder_, IElementType... tokens) {
+    IElementType tokenType = builder_.getTokenType();
+    for (IElementType token : tokens) {
+      if (token == tokenType) return true;
+    }
+    return false;
+  }
+
+  public static boolean nextTokenIs(PsiBuilder builder_, String frameName, IElementType... tokens) {
+    ErrorState state = ErrorState.get(builder_);
+    if (state.completionState != null) return true;
+    boolean track = !state.suppressErrors && state.predicateCount < 2 && state.predicateSign;
+    if (!track) return nextTokenIsFast(builder_, tokens);
+    IElementType tokenType = builder_.getTokenType();
+    if (StringUtil.isNotEmpty(frameName)) {
+      addVariantInner(state, builder_.rawTokenIndex(), frameName);
+    }
+    else {
+      for (IElementType token : tokens) {
+        addVariant(builder_, state, token);
+      }
+    }
+    if (tokenType == null) return false;
+    for (IElementType token : tokens) {
+      if (tokenType == token) return true;
+    }
+    return false;
+  }
+
+  public static boolean nextTokenIs(PsiBuilder builder_, IElementType token) {
+    if (!addVariantSmart(builder_, token, false)) return true;
+    return nextTokenIsFast(builder_, token);
+  }
+
+  public static boolean nextTokenIs(PsiBuilder builder_, String tokenText) {
+    if (!addVariantSmart(builder_, tokenText, false)) return true;
+    return nextTokenIsFast(builder_, tokenText, ErrorState.get(builder_).caseSensitive) > 0;
+  }
+
+  public static boolean nextTokenIsFast(PsiBuilder builder_, String tokenText) {
+    return nextTokenIsFast(builder_, tokenText, ErrorState.get(builder_).caseSensitive) > 0;
+  }
+
+  public static int nextTokenIsFast(PsiBuilder builder_, String tokenText, boolean caseSensitive) {
+    CharSequence sequence = builder_.getOriginalText();
+    int offset = builder_.getCurrentOffset();
+    int endOffset = offset + tokenText.length();
+    CharSequence subSequence = sequence.subSequence(offset, Math.min(endOffset, sequence.length()));
+
+    if (!Comparing.equal(subSequence, tokenText, caseSensitive)) return 0;
+
+    int count = 0;
+    while (true) {
+      int nextOffset = builder_.rawTokenTypeStart(++count);
+      if (nextOffset > endOffset) {
+        return -count;
+      }
+      else if (nextOffset == endOffset) {
+        break;
+      }
+    }
+    return count;
+  }
+
+  private static void addCompletionVariantSmart(PsiBuilder builder_, Object token) {
+    ErrorState state = ErrorState.get(builder_);
+    CompletionState completionState = state.completionState;
+    if (completionState != null && state.predicateCount == 0) {
+      addCompletionVariant(builder_, completionState, token);
+    }
+  }
+
+  private static boolean addVariantSmart(PsiBuilder builder_, Object token, boolean force) {
+    ErrorState state = ErrorState.get(builder_);
+    // skip FIRST check in completion mode
+    if (state.completionState != null && !force) return false;
+    builder_.eof();
+    if (!state.suppressErrors && state.predicateCount < 2) {
+      addVariant(builder_, state, token);
+    }
+    return true;
+  }
+
+  public static void addVariant(PsiBuilder builder_, String text) {
+    addVariant(builder_, ErrorState.get(builder_), text);
+  }
+
+  private static void addVariant(PsiBuilder builder_, ErrorState state, Object o) {
+    builder_.eof(); // skip whitespaces
+    addVariantInner(state, builder_.rawTokenIndex(), o);
+
+    CompletionState completionState = state.completionState;
+    if (completionState != null && state.predicateSign) {
+      addCompletionVariant(builder_, completionState, o);
+    }
+  }
+
+  private static void addVariantInner(ErrorState state, int pos, Object o) {
+    Variant variant = state.VARIANTS.alloc().init(pos, o);
+    if (state.predicateSign) {
+      state.variants.add(variant);
+      if (state.lastExpectedVariantPos < variant.position) {
+        state.lastExpectedVariantPos = variant.position;
+      }
+    }
+    else {
+      state.unexpected.add(variant);
+    }
+  }
+
+  private static void addCompletionVariant(@NotNull PsiBuilder builder_, @NotNull CompletionState completionState, Object o) {
+    int offset = builder_.getCurrentOffset();
+    if (!builder_.eof() && offset == builder_.rawTokenTypeStart(1)) return; // suppress for zero-length tokens
+
+    boolean add = false;
+    int diff = completionState.offset - offset;
+    String text = completionState.convertItem(o);
+    int length = text == null? 0 : text.length();
+    if (length == 0) return;
+    if (diff == 0) {
+      add = true;
+    }
+    else if (diff > 0 && diff <= length) {
+      CharSequence fragment = builder_.getOriginalText().subSequence(offset, completionState.offset);
+      add = completionState.prefixMatches(fragment.toString(), text);
+    }
+    else if (diff < 0) {
+      for (int i=-1; ; i--) {
+        IElementType type = builder_.rawLookup(i);
+        int tokenStart = builder_.rawTokenTypeStart(i);
+        if (isWhitespaceOrComment(builder_, type)) {
+          diff = completionState.offset - tokenStart;
+        }
+        else if (type != null && tokenStart < completionState.offset) {
+          CharSequence fragment = builder_.getOriginalText().subSequence(tokenStart, completionState.offset);
+          if (completionState.prefixMatches(fragment.toString(), text)) {
+            diff = completionState.offset - tokenStart;
+          }
+          break;
+        }
+        else break;
+      }
+      add = diff >= 0 && diff < length;
+    }
+    add = add && length > 1 && !(text.charAt(0) == '<' && text.charAt(length - 1) == '>') &&
+          !(text.charAt(0) == '\'' && text.charAt(length - 1) == '\'' && length < 5);
+    if (add) {
+      completionState.addItem(builder_, text);
+    }
+  }
+
+  public static boolean isWhitespaceOrComment(@NotNull PsiBuilder builder_, @Nullable IElementType type) {
+    return ((PsiBuilderImpl)((Builder)builder_).getDelegate()).whitespaceOrComment(type);
+  }
+
+  // here's the new section API for compact parsers & less IntelliJ platform API exposure
+  public static final int _NONE_       = 0x0;
+  public static final int _COLLAPSE_   = 0x1;
+  public static final int _LEFT_       = 0x2;
+  public static final int _LEFT_INNER_ = 0x4;
+  public static final int _AND_        = 0x8;
+  public static final int _NOT_        = 0x10;
+
+  // simple enter/exit methods pair that doesn't require frame object
+  public static PsiBuilder.Marker enter_section_(PsiBuilder builder_) {
+    return builder_.mark();
+  }
+
+  public static void exit_section_(PsiBuilder builder_,
+                                   PsiBuilder.Marker marker,
+                                   @Nullable IElementType elementType,
+                                   boolean result) {
+    close_marker_impl_(ErrorState.get(builder_).frameStack.peekLast(), marker, elementType, result);
+  }
+
+  // complex enter/exit methods pair with frame object
+  public static PsiBuilder.Marker enter_section_(PsiBuilder builder_, int level, int modifiers, @Nullable String frameName) {
+    PsiBuilder.Marker marker = builder_.mark();
+    enter_section_impl_(builder_, level, modifiers, frameName);
+    return marker;
+  }
+
+  private static void enter_section_impl_(PsiBuilder builder_, int level, int modifiers, @Nullable String frameName) {
+    ErrorState state = ErrorState.get(builder_);
+    Frame frame = state.FRAMES.alloc().init(builder_, state, level, modifiers, frameName);
+    Frame prevFrame = state.frameStack.peekLast();
+    if (prevFrame != null && prevFrame.errorReportedAt > frame.position) {
+      // report error for previous unsuccessful frame
+      reportError(builder_, state, frame, true, false);
+    }
+    if (((frame.modifiers & _LEFT_) | (frame.modifiers & _LEFT_INNER_)) != 0) {
+      PsiBuilder.Marker left = (PsiBuilder.Marker)builder_.getLatestDoneMarker();
+      if (invalid_left_marker_guard_(builder_, left, frameName)) {
+        frame.leftMarker = left;
+      }
+    }
+    state.frameStack.add(frame);
+    if ((modifiers & _AND_) != 0) {
+      if (state.predicateCount == 0 && !state.predicateSign) {
+        throw new AssertionError("Incorrect false predicate sign");
+      }
+      state.predicateCount++;
+    }
+    else if ((modifiers & _NOT_) != 0) {
+      if (state.predicateCount == 0) {
+        state.predicateSign = false;
+      }
+      else {
+        state.predicateSign = !state.predicateSign;
+      }
+      state.predicateCount++;
+    }
+  }
+
+  public static void exit_section_(PsiBuilder builder_,
+                                   int level,
+                                   PsiBuilder.Marker marker,
+                                   @Nullable IElementType elementType,
+                                   boolean result,
+                                   boolean pinned,
+                                   @Nullable Parser eatMore) {
+    ErrorState state = ErrorState.get(builder_);
+
+    Frame frame = state.frameStack.pollLast();
+    if (frame == null || level != frame.level) {
+      LOG.error("Unbalanced error section: got " + frame + ", expected level " + level);
+      if (frame != null) state.FRAMES.recycle(frame);
+      close_marker_impl_(frame, marker, elementType, result);
+      return;
+    }
+
+    if (((frame.modifiers & _AND_) | (frame.modifiers & _NOT_)) != 0) {
+      close_marker_impl_(frame, marker, null, false);
+      state.predicateCount--;
+      if ((frame.modifiers & _NOT_) != 0) state.predicateSign = !state.predicateSign;
+      state.FRAMES.recycle(frame);
+      return;
+    }
+    exit_section_impl_(state, frame, builder_, marker, elementType, result, pinned);
+
+    int initialPos = builder_.rawTokenIndex();
+    boolean willFail = !result && !pinned;
+    if (willFail && initialPos == frame.position && state.lastExpectedVariantPos == frame.position &&
+        frame.name != null && state.variants.size() - frame.variantCount > 1) {
+      state.clearVariants(true, frame.variantCount);
+      addVariantInner(state, initialPos, frame.name);
+    }
+    int lastErrorPos = getLastVariantPos(state, initialPos);
+    if (!state.suppressErrors && eatMore != null) {
+      state.suppressErrors = true;
+      final boolean eatMoreFlagOnce = !builder_.eof() && eatMore.parse(builder_, frame.level + 1);
+      boolean eatMoreFlag = eatMoreFlagOnce || !result && frame.position == initialPos && lastErrorPos > frame.position;
+
+      PsiBuilderImpl.ProductionMarker latestDoneMarker =
+        (pinned || result) && (state.altMode || elementType != null) &&
+        eatMoreFlagOnce ? (PsiBuilderImpl.ProductionMarker)builder_.getLatestDoneMarker() : null;
+      PsiBuilder.Marker extensionMarker = null;
+      IElementType extensionTokenType = null;
+      // whitespace prefix makes the very first frame offset bigger than marker start offset which is always 0
+      if (latestDoneMarker instanceof PsiBuilder.Marker &&
+          frame.position >= latestDoneMarker.getStartIndex() &&
+          frame.position <= latestDoneMarker.getEndIndex()) {
+        extensionMarker = ((PsiBuilder.Marker)latestDoneMarker).precede();
+        extensionTokenType = latestDoneMarker.getTokenType();
+        ((PsiBuilder.Marker)latestDoneMarker).drop();
+      }
+      // advance to the last error pos
+      // skip tokens until lastErrorPos. parseAsTree might look better here...
+      int parenCount = 0;
+      while ((eatMoreFlag || parenCount > 0) && builder_.rawTokenIndex() < lastErrorPos) {
+        builder_.advanceLexer();
+        eatMoreFlag = eatMore.parse(builder_, frame.level + 1);
+      }
+      boolean errorReported = frame.errorReportedAt == initialPos || !result && frame.errorReportedAt >= frame.position;
+      if (errorReported) {
+        if (eatMoreFlag) {
+          builder_.advanceLexer();
+          parseAsTree(state, builder_, frame.level + 1, DUMMY_BLOCK, true, TOKEN_ADVANCER, eatMore);
+        }
+      }
+      else if (eatMoreFlag) {
+        errorReported = reportError(builder_, state, frame, true, true);
+        parseAsTree(state, builder_, frame.level + 1, DUMMY_BLOCK, true, TOKEN_ADVANCER, eatMore);
+      }
+      else if (eatMoreFlagOnce || (!result && frame.position != builder_.rawTokenIndex()) || frame.errorReportedAt > initialPos) {
+        errorReported = reportError(builder_, state, frame, true, false);
+      }
+      if (extensionMarker != null) {
+        extensionMarker.done(extensionTokenType);
+      }
+      state.suppressErrors = false;
+      if (errorReported || result) {
+        state.clearVariants(true, 0);
+        state.clearVariants(false, 0);
+        state.lastExpectedVariantPos = -1;
+      }
+    }
+    else if (!result && pinned && frame.errorReportedAt < 0) {
+      // do not report if there are errors beyond current position
+      if (lastErrorPos == initialPos) {
+        // do not force, inner recoverRoot might have skipped some tokens
+        reportError(builder_, state, frame, false, false);
+      }
+      else if (lastErrorPos > initialPos) {
+        // set error pos here as if it is reported for future reference
+        frame.errorReportedAt = lastErrorPos;
+      }
+    }
+    // propagate errorReportedAt up the stack to avoid duplicate reporting
+    Frame prevFrame = willFail && eatMore == null ? null : state.frameStack.peekLast();
+    if (prevFrame != null && prevFrame.errorReportedAt < frame.errorReportedAt) {
+      prevFrame.errorReportedAt = frame.errorReportedAt;
+    }
+    state.FRAMES.recycle(frame);
+  }
+
+  private static void exit_section_impl_(ErrorState state,
+                                         Frame frame,
+                                         PsiBuilder builder_,
+                                         PsiBuilder.Marker marker,
+                                         IElementType elementType,
+                                         boolean result,
+                                         boolean pinned) {
+    if (elementType != null && marker != null) {
+      if ((frame.modifiers & _COLLAPSE_) != 0) {
+        PsiBuilderImpl.ProductionMarker last = result || pinned? (PsiBuilderImpl.ProductionMarker)builder_.getLatestDoneMarker() : null;
+        if (last != null && last.getStartIndex() == frame.position &&
+            state.typeExtends(last.getTokenType(), elementType)) {
+          IElementType resultType = last.getTokenType();
+          ((PsiBuilder.Marker)last).drop();
+          marker.done(resultType);
+          return;
+        }
+      }
+      if (result || pinned) {
+        if ((frame.modifiers & _LEFT_INNER_) != 0 && frame.leftMarker != null) {
+          marker.done(elementType);
+          frame.leftMarker.precede().done(((LighterASTNode)frame.leftMarker).getTokenType());
+          frame.leftMarker.drop();
+        }
+        else if ((frame.modifiers & _LEFT_) != 0 && frame.leftMarker != null) {
+          marker.drop();
+          frame.leftMarker.precede().done(elementType);
+        }
+        else {
+          if (frame.level == 0) builder_.eof(); // skip whitespaces
+          marker.done(elementType);
+        }
+      }
+      else {
+        close_marker_impl_(frame, marker, null, false);
+      }
+    }
+    else if (result || pinned) {
+      if (marker != null) marker.drop();
+      if ((frame.modifiers & _LEFT_INNER_) != 0 && frame.leftMarker != null) {
+        frame.leftMarker.precede().done(((LighterASTNode)frame.leftMarker).getTokenType());
+        frame.leftMarker.drop();
+      }
+    }
+    else {
+      close_marker_impl_(frame, marker, null, false);
+    }
+  }
+
+  private static void close_marker_impl_(Frame frame, PsiBuilder.Marker marker, IElementType elementType, boolean result) {
+    if (marker == null) return;
+    if (result) {
+      if (elementType != null) {
+        marker.done(elementType);
+      }
+      else {
+        marker.drop();
+      }
+    }
+    else {
+      if (frame != null) {
+        int position = ((PsiBuilderImpl.ProductionMarker)marker).getStartIndex();
+        if (frame.errorReportedAt > position) {
+          frame.errorReportedAt = frame.errorReportedAtPrev;
+        }
+      }
+      marker.rollbackTo();
+    }
+  }
+
+  public static boolean report_error_(PsiBuilder builder_, boolean result_) {
+    if (!result_) report_error_(builder_, ErrorState.get(builder_), false);
+    return result_;
+  }
+
+  public static void report_error_(PsiBuilder builder_, ErrorState state, boolean advance) {
+    Frame frame = state.frameStack.isEmpty()? null : state.frameStack.getLast();
+    if (frame == null) {
+      LOG.error("unbalanced enter/exit section call: got null");
+      return;
+    }
+    int position = builder_.rawTokenIndex();
+    if (frame.errorReportedAt < position && getLastVariantPos(state, position + 1) <= position) {
+      reportError(builder_, state, frame, true, advance);
+    }
+  }
+
+  private static int getLastVariantPos(ErrorState state, int defValue) {
+    return state.lastExpectedVariantPos < 0? defValue : state.lastExpectedVariantPos;
+  }
+
+  private static boolean reportError(PsiBuilder builder_,
+                                     ErrorState state,
+                                     Frame frame,
+                                     boolean force,
+                                     boolean advance) {
+    String expectedText = state.getExpectedText(builder_);
+    boolean notEmpty = StringUtil.isNotEmpty(expectedText);
+    if (force || notEmpty || advance) {
+      String gotText = builder_.eof()? "unexpected end of file" :
+                             notEmpty? "got '" + builder_.getTokenText() +"'" :
+                             "'" + builder_.getTokenText() +"' unexpected";
+      String message = expectedText + gotText;
+      if (advance) {
+        PsiBuilder.Marker mark = builder_.mark();
+        builder_.advanceLexer();
+        mark.error(message);
+      }
+      else {
+        builder_.error(message);
+      }
+      builder_.eof(); // skip whitespaces
+      frame.errorReportedAt = builder_.rawTokenIndex();
+      return true;
+    }
+    return false;
+  }
+
+
+  public static final Key<CompletionState> COMPLETION_STATE_KEY = Key.create("COMPLETION_STATE_KEY");
+
+  public static class CompletionState implements Function<Object, String> {
+    public final int offset;
+    public final Collection<String> items = ContainerUtil.newTroveSet();
+
+    public CompletionState(int offset_) {
+      offset = offset_;
+    }
+
+    @Nullable
+    public String convertItem(Object o) {
+      return o instanceof Object[] ? StringUtil.join((Object[]) o, this, " ") : o.toString();
+    }
+
+    @Override
+    public String fun(Object o) {
+      return o.toString();
+    }
+
+    public void addItem(@NotNull PsiBuilder builder, @NotNull String text) {
+      items.add(text);
+    }
+
+    public boolean prefixMatches(@NotNull String prefix, @NotNull String variant) {
+      return StringUtil.startsWithIgnoreCase(variant, prefix);
+    }
+  }
+
+  public static class Builder extends PsiBuilderAdapter {
+    public final ErrorState state;
+    public final PsiParser parser;
+
+    public Builder(PsiBuilder builder_, ErrorState state_, PsiParser parser_) {
+      super(builder_);
+      state = state_;
+      parser = parser_;
+    }
+
+    public Lexer getLexer() {
+      return ((PsiBuilderImpl)myDelegate).getLexer();
+    }
+  }
+
+  public static PsiBuilder adapt_builder_(IElementType root, PsiBuilder builder, PsiParser parser) {
+    return adapt_builder_(root, builder, parser, null);
+  }
+
+  public static PsiBuilder adapt_builder_(IElementType root, PsiBuilder builder, PsiParser parser, TokenSet[] extendsSets) {
+    ErrorState state = new ErrorState();
+    ErrorState.initState(state, builder, root, extendsSets);
+    return new Builder(builder, state, parser);
+  }
+
+  public static class ErrorState {
+    TokenSet[] extendsSets;
+    public PairProcessor<IElementType, IElementType> altExtendsChecker;
+
+    int predicateCount;
+    boolean predicateSign = true;
+    boolean suppressErrors;
+    public final LinkedList<Frame> frameStack = new LinkedList<Frame>();
+    public CompletionState completionState;
+
+    private boolean caseSensitive;
+    public boolean altMode;
+
+    int lastExpectedVariantPos = -1;
+    MyList<Variant> variants = new MyList<Variant>(INITIAL_VARIANTS_SIZE);
+    MyList<Variant> unexpected = new MyList<Variant>(INITIAL_VARIANTS_SIZE / 10);
+
+    final LimitedPool<Variant> VARIANTS = new LimitedPool<Variant>(VARIANTS_POOL_SIZE, new LimitedPool.ObjectFactory<Variant>() {
+      @Override
+      public Variant create() {
+        return new Variant();
+      }
+
+      @Override
+      public void cleanup(final Variant o) {
+      }
+    });
+    final LimitedPool<Frame> FRAMES = new LimitedPool<Frame>(FRAMES_POOL_SIZE, new LimitedPool.ObjectFactory<Frame>() {
+      @Override
+      public Frame create() {
+        return new Frame();
+      }
+
+      @Override
+      public void cleanup(final Frame o) {
+      }
+    });
+
+    public static ErrorState get(PsiBuilder builder) {
+      return ((Builder)builder).state;
+    }
+
+    public static void initState(ErrorState state, PsiBuilder builder, IElementType root, TokenSet[] extendsSets) {
+      state.extendsSets = extendsSets;
+      PsiFile file = builder.getUserDataUnprotected(FileContextUtil.CONTAINING_FILE_KEY);
+      state.completionState = file == null? null: file.getUserData(COMPLETION_STATE_KEY);
+      Language language = file == null? root.getLanguage() : file.getLanguage();
+      state.caseSensitive = language.isCaseSensitive();
+    }
+
+    public String getExpectedText(PsiBuilder builder_) {
+      int position = builder_.rawTokenIndex();
+      StringBuilder sb = new StringBuilder();
+      if (addExpected(sb, position, true)) {
+        sb.append(" expected, ");
+      }
+      else if (addExpected(sb, position, false)) sb.append(" unexpected, ");
+      return sb.toString();
+    }
+
+    private boolean addExpected(StringBuilder sb, int position, boolean expected) {
+      MyList<Variant> list = expected ? variants : unexpected;
+      String[] strings = new String[list.size()];
+      long[] hashes = new long[strings.length];
+      Arrays.fill(strings, "");
+      int count = 0;
+      loop: for (Variant variant : list) {
+        if (position == variant.position) {
+          String text = variant.object.toString();
+          long hash = StringHash.calc(text);
+          for (int i=0; i<count; i++) {
+            if (hashes[i] == hash) continue loop;
+          }
+          hashes[count] = hash;
+          strings[count] = text;
+          count++;
+        }
+      }
+      Arrays.sort(strings);
+      count = 0;
+      for (String s : strings) {
+        if (s.length() == 0) continue;
+        if (count++ > 0) {
+          if (count > MAX_VARIANTS_TO_DISPLAY) {
+            sb.append(" and ...");
+            break;
+          }
+          else {
+            sb.append(", ");
+          }
+        }
+        char c = s.charAt(0);
+        String displayText = c == '<' || StringUtil.isJavaIdentifierStart(c) ? s : '\'' + s + '\'';
+        sb.append(displayText);
+      }
+      if (count > 1 && count < MAX_VARIANTS_TO_DISPLAY) {
+        int idx = sb.lastIndexOf(", ");
+        sb.replace(idx, idx + 1, " or");
+      }
+      return count > 0;
+    }
+
+    public void clearVariants(boolean expected, int start) {
+      MyList<Variant> list = expected? variants : unexpected;
+      if (start < 0 || start >= list.size()) return;
+      for (int i = start, len = list.size(); i < len; i ++) {
+        VARIANTS.recycle(list.get(i));
+      }
+      list.setSize(start);
+    }
+
+    boolean typeExtends(IElementType child_, IElementType parent_) {
+      if (child_ == parent_) return true;
+      if (extendsSets != null) {
+        for (TokenSet set : extendsSets) {
+          if (set.contains(child_) && set.contains(parent_)) return true;
+        }
+      }
+      return altExtendsChecker != null && altExtendsChecker.process(child_, parent_);
+    }
+  }
+
+  public static class Frame {
+    public int offset;
+    public int position;
+    public int level;
+    public int modifiers;
+    public String name;
+    public int variantCount;
+    public int errorReportedAt;
+    public int errorReportedAtPrev;
+    public PsiBuilder.Marker leftMarker;
+
+    public Frame() {
+    }
+
+    public Frame init(PsiBuilder builder_, ErrorState state, int level_, int modifiers_, String name_) {
+      offset = builder_.getCurrentOffset();
+      position = builder_.rawTokenIndex();
+      level = level_;
+      modifiers = modifiers_;
+      name = name_;
+      variantCount = state.variants.size();
+      errorReportedAt = -1;
+
+      Frame prev = state.frameStack.peekLast();
+      errorReportedAtPrev = prev == null? -1 : prev.errorReportedAt;
+      leftMarker = null;
+      return this;
+    }
+
+    @Override
+    public String toString() {
+      String mod = modifiers == _NONE_ ? "_NONE_, " :
+        ((modifiers & _COLLAPSE_) != 0? "_CAN_COLLAPSE_, ": "") +
+        ((modifiers & _LEFT_) != 0? "_LEFT_, ": "") +
+        ((modifiers & _LEFT_INNER_) != 0? "_LEFT_INNER_, ": "") +
+        ((modifiers & _AND_) != 0? "_AND_, ": "") +
+        ((modifiers & _NOT_) != 0? "_NOT_, ": "");
+      return String.format("{%s:%s:%d, %d, %s%s}", offset, position, level, errorReportedAt, mod, name);
+    }
+  }
+
+
+  private static class Variant {
+    int position;
+    Object object;
+
+    public Variant init(int pos, Object o) {
+      position = pos;
+      object = o;
+      return this;
+    }
+
+    @Override
+    public String toString() {
+      return "<" + position + ", " + object + ">";
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+
+      Variant variant = (Variant)o;
+
+      if (position != variant.position) return false;
+      if (!this.object.equals(variant.object)) return false;
+
+      return true;
+    }
+
+    @Override
+    public int hashCode() {
+      int result = position;
+      result = 31 * result + object.hashCode();
+      return result;
+    }
+  }
+
+
+  private static final int MAX_CHILDREN_IN_TREE = 10;
+  public static boolean parseAsTree(ErrorState state, final PsiBuilder builder_, int level, final IElementType chunkType,
+                                    boolean checkBraces, final Parser parser, final Parser eatMoreCondition) {
+    final LinkedList<Pair<PsiBuilder.Marker, PsiBuilder.Marker>> parenList = new LinkedList<Pair<PsiBuilder.Marker, PsiBuilder.Marker>>();
+    final LinkedList<Pair<PsiBuilder.Marker, Integer>> siblingList = new LinkedList<Pair<PsiBuilder.Marker, Integer>>();
+    PsiBuilder.Marker marker = null;
+
+    final Runnable checkSiblingsRunnable = new Runnable() {
+      @Override
+      public void run() {
+        main:
+        while (!siblingList.isEmpty()) {
+          final Pair<PsiBuilder.Marker, PsiBuilder.Marker> parenPair = parenList.peek();
+          final int rating = siblingList.getFirst().second;
+          int count = 0;
+          for (Pair<PsiBuilder.Marker, Integer> pair : siblingList) {
+            if (pair.second != rating || parenPair != null && pair.first == parenPair.second) break main;
+            if (++count >= MAX_CHILDREN_IN_TREE) {
+              final PsiBuilder.Marker parentMarker = pair.first.precede();
+              while (count-- > 0) {
+                siblingList.removeFirst();
+              }
+              parentMarker.done(chunkType);
+              siblingList.addFirst(Pair.create(parentMarker, rating + 1));
+              continue main;
+            }
+          }
+          break;
+        }
+      }
+    };
+    int totalCount = 0;
+    int tokenCount = 0;
+    while (true) {
+      final IElementType tokenType = builder_.getTokenType();
+        if (marker == null) {
+          marker = builder_.mark();
+        }
+        final boolean result = (!parenList.isEmpty() || eatMoreCondition.parse(builder_, level + 1)) && parser.parse(builder_, level + 1);
+        if (result) {
+          tokenCount++;
+          totalCount++;
+        }
+        if (!result) {
+          break;
+        }
+
+        if (tokenCount >= MAX_CHILDREN_IN_TREE && marker != null) {
+        marker.done(chunkType);
+        siblingList.addFirst(Pair.create(marker, 1));
+        checkSiblingsRunnable.run();
+        marker = null;
+        tokenCount = 0;
+      }
+    }
+    if (marker != null) {
+      marker.drop();
+    }
+    for (Pair<PsiBuilder.Marker, PsiBuilder.Marker> pair : parenList) {
+      pair.first.drop();
+    }
+    return totalCount != 0;
+  }
+
+  private static class DummyBlockElementType extends IElementType implements ICompositeElementType{
+    DummyBlockElementType() {
+      super("DUMMY_BLOCK", Language.ANY);
+    }
+
+    @NotNull
+    @Override
+    public ASTNode createCompositeNode() {
+      return new DummyBlock();
+    }
+  }
+
+  public static class DummyBlock extends CompositePsiElement {
+    DummyBlock() {
+      super(DUMMY_BLOCK);
+    }
+
+    @NotNull
+    @Override
+    public PsiReference[] getReferences() {
+      return PsiReference.EMPTY_ARRAY;
+    }
+
+    @NotNull
+    @Override
+    public Language getLanguage() {
+      return getParent().getLanguage();
+    }
+  }
+
+  private static class MyList<E> extends ArrayList<E> {
+    MyList(int initialCapacity) {
+      super(initialCapacity);
+    }
+
+    protected void setSize(int fromIndex) {
+      removeRange(fromIndex, size());
+    }
+
+    @Override
+    public boolean add(E e) {
+      int size = size();
+      if (size >= MAX_VARIANTS_SIZE) {
+        removeRange(MAX_VARIANTS_SIZE / 4, size - MAX_VARIANTS_SIZE / 4);
+      }
+      return super.add(e);
+    }
+  }
+}