core/src/main/java/com/google/googlejavaformat/OpsBuilder.java - platform/external/google-java-format - Git at Google

 /*
  * Copyright 2015 Google Inc.
  *
  * 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 com.google.googlejavaformat;

 import com.google.common.base.MoreObjects;
 import com.google.common.collect.ArrayListMultimap;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Multimap;
 import com.google.googlejavaformat.Indent.Const;
 import com.google.googlejavaformat.Input.Tok;
 import com.google.googlejavaformat.Input.Token;
 import com.google.googlejavaformat.Output.BreakTag;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;

 /**
  * An {@code OpsBuilder} creates a list of {@link Op}s, which is turned into a {@link Doc} by {@link
  * DocBuilder}.
  */
 public final class OpsBuilder {

   /** @return the actual size of the AST node at position, including comments. */
   public int actualSize(int position, int length) {
     Token startToken = input.getPositionTokenMap().get(position);
     int start = startToken.getTok().getPosition();
     for (Tok tok : startToken.getToksBefore()) {
       if (tok.isComment()) {
         start = Math.min(start, tok.getPosition());
       }
     }
     Token endToken = input.getPositionTokenMap().get(position + length - 1);
     int end = endToken.getTok().getPosition() + endToken.getTok().length();
     for (Tok tok : endToken.getToksAfter()) {
       if (tok.isComment()) {
         end = Math.max(end, tok.getPosition() + tok.length());
       }
     }
     return end - start;
   }

   /** @return the start column of the token at {@code position}, including leading comments. */
   public Integer actualStartColumn(int position) {
     Token startToken = input.getPositionTokenMap().get(position);
     int start = startToken.getTok().getPosition();
     int line0 = input.getLineNumber(start);
     for (Tok tok : startToken.getToksBefore()) {
       if (line0 != input.getLineNumber(tok.getPosition())) {
         return start;
       }
       if (tok.isComment()) {
         start = Math.min(start, tok.getPosition());
       }
     }
     return start;
   }

   /** A request to add or remove a blank line in the output. */
   public abstract static class BlankLineWanted {

     /** Always emit a blank line. */
     public static final BlankLineWanted YES = new SimpleBlankLine(Optional.of(true));

     /** Never emit a blank line. */
     public static final BlankLineWanted NO = new SimpleBlankLine(Optional.of(false));

     /**
      * Explicitly preserve blank lines from the input (e.g. before the first member in a class
      * declaration). Overrides conditional blank lines.
      */
     public static final BlankLineWanted PRESERVE =
         new SimpleBlankLine(/* wanted= */ Optional.empty());

     /** Is the blank line wanted? */
     public abstract Optional<Boolean> wanted();

     /** Merge this blank line request with another. */
     public abstract BlankLineWanted merge(BlankLineWanted wanted);

     /** Emit a blank line if the given break is taken. */
     public static BlankLineWanted conditional(BreakTag breakTag) {
       return new ConditionalBlankLine(ImmutableList.of(breakTag));
     }

     private static final class SimpleBlankLine extends BlankLineWanted {
       private final Optional<Boolean> wanted;

       SimpleBlankLine(Optional<Boolean> wanted) {
         this.wanted = wanted;
       }

       @Override
       public Optional<Boolean> wanted() {
         return wanted;
       }

       @Override
       public BlankLineWanted merge(BlankLineWanted other) {
         return this;
       }
     }

     private static final class ConditionalBlankLine extends BlankLineWanted {

       private final ImmutableList<BreakTag> tags;

       ConditionalBlankLine(Iterable<BreakTag> tags) {
         this.tags = ImmutableList.copyOf(tags);
       }

       @Override
       public Optional<Boolean> wanted() {
         for (BreakTag tag : tags) {
           if (tag.wasBreakTaken()) {
             return Optional.of(true);
           }
         }
         return Optional.empty();
       }

       @Override
       public BlankLineWanted merge(BlankLineWanted other) {
         if (!(other instanceof ConditionalBlankLine)) {
           return other;
         }
         return new ConditionalBlankLine(
             Iterables.concat(this.tags, ((ConditionalBlankLine) other).tags));
       }
     }
   }

   private final Input input;
   private final List<Op> ops = new ArrayList<>();
   private final Output output;
   private static final Indent.Const ZERO = Indent.Const.ZERO;

   private int tokenI = 0;
   private int inputPosition = Integer.MIN_VALUE;

   /** The number of unclosed open ops in the input stream. */
   int depth = 0;

   /** Add an {@link Op}, and record open/close ops for later validation of unclosed levels. */
   private void add(Op op) {
     if (op instanceof OpenOp) {
       depth++;
     } else if (op instanceof CloseOp) {
       depth--;
       if (depth < 0) {
         throw new AssertionError();
       }
     }
     ops.add(op);
   }

   /** Add a list of {@link Op}s. */
   public final void addAll(List<Op> ops) {
     for (Op op : ops) {
       add(op);
     }
   }

   /**
    * The {@code OpsBuilder} constructor.
    *
    * @param input the {@link Input}, used for retrieve information from the AST
    * @param output the {@link Output}, used here only to record blank-line information
    */
   public OpsBuilder(Input input, Output output) {
     this.input = input;
     this.output = output;
   }

   /** Get the {@code OpsBuilder}'s {@link Input}. */
   public final Input getInput() {
     return input;
   }

   /** Returns the number of unclosed open ops in the input stream. */
   public int depth() {
     return depth;
   }

   /**
    * Checks that all open ops in the op stream have matching close ops.
    *
    * @throws FormattingError if any ops were unclosed
    */
   public void checkClosed(int previous) {
     if (depth != previous) {
       throw new FormattingError(diagnostic(String.format("saw %d unclosed ops", depth)));
     }
   }

   /** Create a {@link FormatterDiagnostic} at the current position. */
   public FormatterDiagnostic diagnostic(String message) {
     return input.createDiagnostic(inputPosition, message);
   }

   /**
    * Sync to position in the input. If we've skipped outputting any tokens that were present in the
    * input tokens, output them here and optionally complain.
    *
    * @param inputPosition the {@code 0}-based input position
    */
   public final void sync(int inputPosition) {
     if (inputPosition > this.inputPosition) {
       ImmutableList<? extends Input.Token> tokens = input.getTokens();
       int tokensN = tokens.size();
       this.inputPosition = inputPosition;
       if (tokenI < tokensN && inputPosition > tokens.get(tokenI).getTok().getPosition()) {
         // Found a missing input token. Insert it and mark it missing (usually not good).
         Input.Token token = tokens.get(tokenI++);
         throw new FormattingError(
             diagnostic(String.format("did not generate token \"%s\"", token.getTok().getText())));
       }
     }
   }

   /** Output any remaining tokens from the input stream (e.g. terminal whitespace). */
   public final void drain() {
     int inputPosition = input.getText().length() + 1;
     if (inputPosition > this.inputPosition) {
       ImmutableList<? extends Input.Token> tokens = input.getTokens();
       int tokensN = tokens.size();
       while (tokenI < tokensN && inputPosition > tokens.get(tokenI).getTok().getPosition()) {
         Input.Token token = tokens.get(tokenI++);
         add(
             Doc.Token.make(
                 token,
                 Doc.Token.RealOrImaginary.IMAGINARY,
                 ZERO,
                 /* breakAndIndentTrailingComment= */ Optional.empty()));
       }
     }
     this.inputPosition = inputPosition;
     checkClosed(0);
   }

   /**
    * Open a new level by emitting an {@link OpenOp}.
    *
    * @param plusIndent the extra indent for the new level
    */
   public final void open(Indent plusIndent) {
     add(OpenOp.make(plusIndent));
   }

   /** Close the current level, by emitting a {@link CloseOp}. */
   public final void close() {
     add(CloseOp.make());
   }

   /** Return the text of the next {@link Input.Token}, or absent if there is none. */
   public final Optional<String> peekToken() {
     return peekToken(0);
   }

   /** Return the text of an upcoming {@link Input.Token}, or absent if there is none. */
   public final Optional<String> peekToken(int skip) {
     ImmutableList<? extends Input.Token> tokens = input.getTokens();
     int idx = tokenI + skip;
     return idx < tokens.size()
         ? Optional.of(tokens.get(idx).getTok().getOriginalText())
         : Optional.empty();
   }

   /**
    * Emit an optional token iff it exists on the input. This is used to emit tokens whose existence
    * has been lost in the AST.
    *
    * @param token the optional token
    */
   public final void guessToken(String token) {
     token(
         token,
         Doc.Token.RealOrImaginary.IMAGINARY,
         ZERO,
         /* breakAndIndentTrailingComment=  */ Optional.empty());
   }

   public final void token(
       String token,
       Doc.Token.RealOrImaginary realOrImaginary,
       Indent plusIndentCommentsBefore,
       Optional<Indent> breakAndIndentTrailingComment) {
     ImmutableList<? extends Input.Token> tokens = input.getTokens();
     if (token.equals(peekToken().orElse(null))) { // Found the input token. Output it.
       add(
           Doc.Token.make(
               tokens.get(tokenI++),
               Doc.Token.RealOrImaginary.REAL,
               plusIndentCommentsBefore,
               breakAndIndentTrailingComment));
     } else {
       /*
        * Generated a "bad" token, which doesn't exist on the input. Drop it, and complain unless
        * (for example) we're guessing at an optional token.
        */
       if (realOrImaginary.isReal()) {
         throw new FormattingError(
             diagnostic(
                 String.format(
                     "expected token: '%s'; generated %s instead",
                     peekToken().orElse(null), token)));
       }
     }
   }

   /**
    * Emit a single- or multi-character op by breaking it into single-character {@link Doc.Token}s.
    *
    * @param op the operator to emit
    */
   public final void op(String op) {
     int opN = op.length();
     for (int i = 0; i < opN; i++) {
       token(
           op.substring(i, i + 1),
           Doc.Token.RealOrImaginary.REAL,
           ZERO,
           /* breakAndIndentTrailingComment=  */ Optional.empty());
     }
   }

   /** Emit a {@link Doc.Space}. */
   public final void space() {
     add(Doc.Space.make());
   }

   /** Emit a {@link Doc.Break}. */
   public final void breakOp() {
     breakOp(Doc.FillMode.UNIFIED, "", ZERO);
   }

   /**
    * Emit a {@link Doc.Break}.
    *
    * @param plusIndent extra indent if taken
    */
   public final void breakOp(Indent plusIndent) {
     breakOp(Doc.FillMode.UNIFIED, "", plusIndent);
   }

   /** Emit a filled {@link Doc.Break}. */
   public final void breakToFill() {
     breakOp(Doc.FillMode.INDEPENDENT, "", ZERO);
   }

   /** Emit a forced {@link Doc.Break}. */
   public final void forcedBreak() {
     breakOp(Doc.FillMode.FORCED, "", ZERO);
   }

   /**
    * Emit a forced {@link Doc.Break}.
    *
    * @param plusIndent extra indent if taken
    */
   public final void forcedBreak(Indent plusIndent) {
     breakOp(Doc.FillMode.FORCED, "", plusIndent);
   }

   /**
    * Emit a {@link Doc.Break}, with a specified {@code flat} value (e.g., {@code " "}).
    *
    * @param flat the {@link Doc.Break} when not broken
    */
   public final void breakOp(String flat) {
     breakOp(Doc.FillMode.UNIFIED, flat, ZERO);
   }

   /**
    * Emit a {@link Doc.Break}, with a specified {@code flat} value (e.g., {@code " "}).
    *
    * @param flat the {@link Doc.Break} when not broken
    */
   public final void breakToFill(String flat) {
     breakOp(Doc.FillMode.INDEPENDENT, flat, ZERO);
   }

   /**
    * Emit a generic {@link Doc.Break}.
    *
    * @param fillMode the {@link Doc.FillMode}
    * @param flat the {@link Doc.Break} when not broken
    * @param plusIndent extra indent if taken
    */
   public final void breakOp(Doc.FillMode fillMode, String flat, Indent plusIndent) {
     breakOp(fillMode, flat, plusIndent, /* optionalTag=  */ Optional.empty());
   }

   /**
    * Emit a generic {@link Doc.Break}.
    *
    * @param fillMode the {@link Doc.FillMode}
    * @param flat the {@link Doc.Break} when not broken
    * @param plusIndent extra indent if taken
    * @param optionalTag an optional tag for remembering whether the break was taken
    */
   public final void breakOp(
       Doc.FillMode fillMode, String flat, Indent plusIndent, Optional<BreakTag> optionalTag) {
     add(Doc.Break.make(fillMode, flat, plusIndent, optionalTag));
   }

   private int lastPartialFormatBoundary = -1;

   /**
    * Make the boundary of a region that can be partially formatted. The boundary will be included in
    * the following region, e.g.: [[boundary0, boundary1), [boundary1, boundary2), ...].
    */
   public void markForPartialFormat() {
     if (lastPartialFormatBoundary == -1) {
       lastPartialFormatBoundary = tokenI;
       return;
     }
     if (tokenI == lastPartialFormatBoundary) {
       return;
     }
     Token start = input.getTokens().get(lastPartialFormatBoundary);
     Token end = input.getTokens().get(tokenI - 1);
     output.markForPartialFormat(start, end);
     lastPartialFormatBoundary = tokenI;
   }

   /**
    * Force or suppress a blank line here in the output.
    *
    * @param wanted whether to force ({@code true}) or suppress {@code false}) the blank line
    */
   public final void blankLineWanted(BlankLineWanted wanted) {
     output.blankLine(getI(input.getTokens().get(tokenI)), wanted);
   }

   private static int getI(Input.Token token) {
     for (Input.Tok tok : token.getToksBefore()) {
       if (tok.getIndex() >= 0) {
         return tok.getIndex();
       }
     }
     return token.getTok().getIndex();
   }

   private static final Doc.Space SPACE = Doc.Space.make();

   /**
    * Build a list of {@link Op}s from the {@code OpsBuilder}.
    *
    * @return the list of {@link Op}s
    */
   public final ImmutableList<Op> build() {
     markForPartialFormat();
     // Rewrite the ops to insert comments.
     Multimap<Integer, Op> tokOps = ArrayListMultimap.create();
     int opsN = ops.size();
     for (int i = 0; i < opsN; i++) {
       Op op = ops.get(i);
       if (op instanceof Doc.Token) {
         /*
          * Token ops can have associated non-tokens, including comments, which we need to insert.
          * They can also cause line breaks, so we insert them before or after the current level,
          * when possible.
          */
         Doc.Token tokenOp = (Doc.Token) op;
         Input.Token token = tokenOp.getToken();
         int j = i; // Where to insert toksBefore before.
         while (0 < j && ops.get(j - 1) instanceof OpenOp) {
           --j;
         }
         int k = i; // Where to insert toksAfter after.
         while (k + 1 < opsN && ops.get(k + 1) instanceof CloseOp) {
           ++k;
         }
         if (tokenOp.realOrImaginary().isReal()) {
           /*
            * Regular input token. Copy out toksBefore before token, and toksAfter after it. Insert
            * this token's toksBefore at position j.
            */
           int newlines = 0; // Count of newlines in a row.
           boolean space = false; // Do we need an extra space after a previous "/*" comment?
           boolean lastWasComment = false; // Was the last thing we output a comment?
           boolean allowBlankAfterLastComment = false;
           for (Input.Tok tokBefore : token.getToksBefore()) {
             if (tokBefore.isNewline()) {
               newlines++;
             } else if (tokBefore.isComment()) {
               tokOps.put(
                   j,
                   Doc.Break.make(
                       tokBefore.isSlashSlashComment() ? Doc.FillMode.FORCED : Doc.FillMode.UNIFIED,
                       "",
                       tokenOp.getPlusIndentCommentsBefore()));
               tokOps.putAll(j, makeComment(tokBefore));
               space = tokBefore.isSlashStarComment();
               newlines = 0;
               lastWasComment = true;
               if (tokBefore.isJavadocComment()) {
                 tokOps.put(j, Doc.Break.makeForced());
               }
               allowBlankAfterLastComment =
                   tokBefore.isSlashSlashComment()
                       || (tokBefore.isSlashStarComment() && !tokBefore.isJavadocComment());
             }
           }
           if (allowBlankAfterLastComment && newlines > 1) {
             // Force a line break after two newlines in a row following a line or block comment
             output.blankLine(token.getTok().getIndex(), BlankLineWanted.YES);
           }
           if (lastWasComment && newlines > 0) {
             tokOps.put(j, Doc.Break.makeForced());
           } else if (space) {
             tokOps.put(j, SPACE);
           }
           // Now we've seen the Token; output the toksAfter.
           for (Input.Tok tokAfter : token.getToksAfter()) {
             if (tokAfter.isComment()) {
               boolean breakAfter =
                   tokAfter.isJavadocComment()
                       || (tokAfter.isSlashStarComment()
                           && tokenOp.breakAndIndentTrailingComment().isPresent());
               if (breakAfter) {
                 tokOps.put(
                     k + 1,
                     Doc.Break.make(
                         Doc.FillMode.FORCED,
                         "",
                         tokenOp.breakAndIndentTrailingComment().orElse(Const.ZERO)));
               } else {
                 tokOps.put(k + 1, SPACE);
               }
               tokOps.putAll(k + 1, makeComment(tokAfter));
               if (breakAfter) {
                 tokOps.put(k + 1, Doc.Break.make(Doc.FillMode.FORCED, "", ZERO));
               }
             }
           }
         } else {
           /*
            * This input token was mistakenly not generated for output. As no whitespace or comments
            * were generated (presumably), copy all input non-tokens literally, even spaces and
            * newlines.
            */
           int newlines = 0;
           boolean lastWasComment = false;
           for (Input.Tok tokBefore : token.getToksBefore()) {
             if (tokBefore.isNewline()) {
               newlines++;
             } else if (tokBefore.isComment()) {
               newlines = 0;
               lastWasComment = tokBefore.isComment();
             }
             if (lastWasComment && newlines > 0) {
               tokOps.put(j, Doc.Break.makeForced());
             }
             tokOps.put(j, Doc.Tok.make(tokBefore));
           }
           for (Input.Tok tokAfter : token.getToksAfter()) {
             tokOps.put(k + 1, Doc.Tok.make(tokAfter));
           }
         }
       }
     }
     /*
      * Construct new list of ops, splicing in the comments. If a comment is inserted immediately
      * before a space, suppress the space.
      */
     ImmutableList.Builder<Op> newOps = ImmutableList.builder();
     boolean afterForcedBreak = false; // Was the last Op a forced break? If so, suppress spaces.
     for (int i = 0; i < opsN; i++) {
       for (Op op : tokOps.get(i)) {
         if (!(afterForcedBreak && op instanceof Doc.Space)) {
           newOps.add(op);
           afterForcedBreak = isForcedBreak(op);
         }
       }
       Op op = ops.get(i);
       if (afterForcedBreak
           && (op instanceof Doc.Space
               || (op instanceof Doc.Break
                   && ((Doc.Break) op).getPlusIndent() == 0
                   && " ".equals(((Doc) op).getFlat())))) {
         continue;
       }
       newOps.add(op);
       if (!(op instanceof OpenOp)) {
         afterForcedBreak = isForcedBreak(op);
       }
     }
     for (Op op : tokOps.get(opsN)) {
       if (!(afterForcedBreak && op instanceof Doc.Space)) {
         newOps.add(op);
         afterForcedBreak = isForcedBreak(op);
       }
     }
     return newOps.build();
   }

   private static boolean isForcedBreak(Op op) {
     return op instanceof Doc.Break && ((Doc.Break) op).isForced();
   }

   private static List<Op> makeComment(Input.Tok comment) {
     return comment.isSlashStarComment()
         ? ImmutableList.of(Doc.Tok.make(comment))
         : ImmutableList.of(Doc.Tok.make(comment), Doc.Break.makeForced());
   }

   @Override
   public final String toString() {
     return MoreObjects.toStringHelper(this)
         .add("input", input)
         .add("ops", ops)
         .add("output", output)
         .add("tokenI", tokenI)
         .add("inputPosition", inputPosition)
         .toString();
   }
 }
	/*
	* Copyright 2015 Google Inc.
	*
	* 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 com.google.googlejavaformat;

	import com.google.common.base.MoreObjects;
	import com.google.common.collect.ArrayListMultimap;
	import com.google.common.collect.ImmutableList;
	import com.google.common.collect.Iterables;
	import com.google.common.collect.Multimap;
	import com.google.googlejavaformat.Indent.Const;
	import com.google.googlejavaformat.Input.Tok;
	import com.google.googlejavaformat.Input.Token;
	import com.google.googlejavaformat.Output.BreakTag;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Optional;

	/**
	* An {@code OpsBuilder} creates a list of {@link Op}s, which is turned into a {@link Doc} by {@link
	* DocBuilder}.
	*/
	public final class OpsBuilder {

	/** @return the actual size of the AST node at position, including comments. */
	public int actualSize(int position, int length) {
	Token startToken = input.getPositionTokenMap().get(position);
	int start = startToken.getTok().getPosition();
	for (Tok tok : startToken.getToksBefore()) {
	if (tok.isComment()) {
	start = Math.min(start, tok.getPosition());
	}
	}
	Token endToken = input.getPositionTokenMap().get(position + length - 1);
	int end = endToken.getTok().getPosition() + endToken.getTok().length();
	for (Tok tok : endToken.getToksAfter()) {
	if (tok.isComment()) {
	end = Math.max(end, tok.getPosition() + tok.length());
	}
	}
	return end - start;
	}

	/** @return the start column of the token at {@code position}, including leading comments. */
	public Integer actualStartColumn(int position) {
	Token startToken = input.getPositionTokenMap().get(position);
	int start = startToken.getTok().getPosition();
	int line0 = input.getLineNumber(start);
	for (Tok tok : startToken.getToksBefore()) {
	if (line0 != input.getLineNumber(tok.getPosition())) {
	return start;
	}
	if (tok.isComment()) {
	start = Math.min(start, tok.getPosition());
	}
	}
	return start;
	}

	/** A request to add or remove a blank line in the output. */
	public abstract static class BlankLineWanted {

	/** Always emit a blank line. */
	public static final BlankLineWanted YES = new SimpleBlankLine(Optional.of(true));

	/** Never emit a blank line. */
	public static final BlankLineWanted NO = new SimpleBlankLine(Optional.of(false));

	/**
	* Explicitly preserve blank lines from the input (e.g. before the first member in a class
	* declaration). Overrides conditional blank lines.
	*/
	public static final BlankLineWanted PRESERVE =
	new SimpleBlankLine(/* wanted= */ Optional.empty());

	/** Is the blank line wanted? */
	public abstract Optional<Boolean> wanted();

	/** Merge this blank line request with another. */
	public abstract BlankLineWanted merge(BlankLineWanted wanted);

	/** Emit a blank line if the given break is taken. */
	public static BlankLineWanted conditional(BreakTag breakTag) {
	return new ConditionalBlankLine(ImmutableList.of(breakTag));
	}

	private static final class SimpleBlankLine extends BlankLineWanted {
	private final Optional<Boolean> wanted;

	SimpleBlankLine(Optional<Boolean> wanted) {
	this.wanted = wanted;
	}

	@Override
	public Optional<Boolean> wanted() {
	return wanted;
	}

	@Override
	public BlankLineWanted merge(BlankLineWanted other) {
	return this;
	}
	}

	private static final class ConditionalBlankLine extends BlankLineWanted {

	private final ImmutableList<BreakTag> tags;

	ConditionalBlankLine(Iterable<BreakTag> tags) {
	this.tags = ImmutableList.copyOf(tags);
	}

	@Override
	public Optional<Boolean> wanted() {
	for (BreakTag tag : tags) {
	if (tag.wasBreakTaken()) {
	return Optional.of(true);
	}
	}
	return Optional.empty();
	}

	@Override
	public BlankLineWanted merge(BlankLineWanted other) {
	if (!(other instanceof ConditionalBlankLine)) {
	return other;
	}
	return new ConditionalBlankLine(
	Iterables.concat(this.tags, ((ConditionalBlankLine) other).tags));
	}
	}
	}

	private final Input input;
	private final List<Op> ops = new ArrayList<>();
	private final Output output;
	private static final Indent.Const ZERO = Indent.Const.ZERO;

	private int tokenI = 0;
	private int inputPosition = Integer.MIN_VALUE;

	/** The number of unclosed open ops in the input stream. */
	int depth = 0;

	/** Add an {@link Op}, and record open/close ops for later validation of unclosed levels. */
	private void add(Op op) {
	if (op instanceof OpenOp) {
	depth++;
	} else if (op instanceof CloseOp) {
	depth--;
	if (depth < 0) {
	throw new AssertionError();
	}
	}
	ops.add(op);
	}

	/** Add a list of {@link Op}s. */
	public final void addAll(List<Op> ops) {
	for (Op op : ops) {
	add(op);
	}
	}

	/**
	* The {@code OpsBuilder} constructor.
	*
	* @param input the {@link Input}, used for retrieve information from the AST
	* @param output the {@link Output}, used here only to record blank-line information
	*/
	public OpsBuilder(Input input, Output output) {
	this.input = input;
	this.output = output;
	}

	/** Get the {@code OpsBuilder}'s {@link Input}. */
	public final Input getInput() {
	return input;
	}

	/** Returns the number of unclosed open ops in the input stream. */
	public int depth() {
	return depth;
	}

	/**
	* Checks that all open ops in the op stream have matching close ops.
	*
	* @throws FormattingError if any ops were unclosed
	*/
	public void checkClosed(int previous) {
	if (depth != previous) {
	throw new FormattingError(diagnostic(String.format("saw %d unclosed ops", depth)));
	}
	}

	/** Create a {@link FormatterDiagnostic} at the current position. */
	public FormatterDiagnostic diagnostic(String message) {
	return input.createDiagnostic(inputPosition, message);
	}

	/**
	* Sync to position in the input. If we've skipped outputting any tokens that were present in the
	* input tokens, output them here and optionally complain.
	*
	* @param inputPosition the {@code 0}-based input position
	*/
	public final void sync(int inputPosition) {
	if (inputPosition > this.inputPosition) {
	ImmutableList<? extends Input.Token> tokens = input.getTokens();
	int tokensN = tokens.size();
	this.inputPosition = inputPosition;
	if (tokenI < tokensN && inputPosition > tokens.get(tokenI).getTok().getPosition()) {
	// Found a missing input token. Insert it and mark it missing (usually not good).
	Input.Token token = tokens.get(tokenI++);
	throw new FormattingError(
	diagnostic(String.format("did not generate token \"%s\"", token.getTok().getText())));
	}
	}
	}

	/** Output any remaining tokens from the input stream (e.g. terminal whitespace). */
	public final void drain() {
	int inputPosition = input.getText().length() + 1;
	if (inputPosition > this.inputPosition) {
	ImmutableList<? extends Input.Token> tokens = input.getTokens();
	int tokensN = tokens.size();
	while (tokenI < tokensN && inputPosition > tokens.get(tokenI).getTok().getPosition()) {
	Input.Token token = tokens.get(tokenI++);
	add(
	Doc.Token.make(
	token,
	Doc.Token.RealOrImaginary.IMAGINARY,
	ZERO,
	/* breakAndIndentTrailingComment= */ Optional.empty()));
	}
	}
	this.inputPosition = inputPosition;
	checkClosed(0);
	}

	/**
	* Open a new level by emitting an {@link OpenOp}.
	*
	* @param plusIndent the extra indent for the new level
	*/
	public final void open(Indent plusIndent) {
	add(OpenOp.make(plusIndent));
	}

	/** Close the current level, by emitting a {@link CloseOp}. */
	public final void close() {
	add(CloseOp.make());
	}

	/** Return the text of the next {@link Input.Token}, or absent if there is none. */
	public final Optional<String> peekToken() {
	return peekToken(0);
	}

	/** Return the text of an upcoming {@link Input.Token}, or absent if there is none. */
	public final Optional<String> peekToken(int skip) {
	ImmutableList<? extends Input.Token> tokens = input.getTokens();
	int idx = tokenI + skip;
	return idx < tokens.size()
	? Optional.of(tokens.get(idx).getTok().getOriginalText())
	: Optional.empty();
	}

	/**
	* Emit an optional token iff it exists on the input. This is used to emit tokens whose existence
	* has been lost in the AST.
	*
	* @param token the optional token
	*/
	public final void guessToken(String token) {
	token(
	token,
	Doc.Token.RealOrImaginary.IMAGINARY,
	ZERO,
	/* breakAndIndentTrailingComment= */ Optional.empty());
	}

	public final void token(
	String token,
	Doc.Token.RealOrImaginary realOrImaginary,
	Indent plusIndentCommentsBefore,
	Optional<Indent> breakAndIndentTrailingComment) {
	ImmutableList<? extends Input.Token> tokens = input.getTokens();
	if (token.equals(peekToken().orElse(null))) { // Found the input token. Output it.
	add(
	Doc.Token.make(
	tokens.get(tokenI++),
	Doc.Token.RealOrImaginary.REAL,
	plusIndentCommentsBefore,
	breakAndIndentTrailingComment));
	} else {
	/*
	* Generated a "bad" token, which doesn't exist on the input. Drop it, and complain unless
	* (for example) we're guessing at an optional token.
	*/
	if (realOrImaginary.isReal()) {
	throw new FormattingError(
	diagnostic(
	String.format(
	"expected token: '%s'; generated %s instead",
	peekToken().orElse(null), token)));
	}
	}
	}

	/**
	* Emit a single- or multi-character op by breaking it into single-character {@link Doc.Token}s.
	*
	* @param op the operator to emit
	*/
	public final void op(String op) {
	int opN = op.length();
	for (int i = 0; i < opN; i++) {
	token(
	op.substring(i, i + 1),
	Doc.Token.RealOrImaginary.REAL,
	ZERO,
	/* breakAndIndentTrailingComment= */ Optional.empty());
	}
	}

	/** Emit a {@link Doc.Space}. */
	public final void space() {
	add(Doc.Space.make());
	}

	/** Emit a {@link Doc.Break}. */
	public final void breakOp() {
	breakOp(Doc.FillMode.UNIFIED, "", ZERO);
	}

	/**
	* Emit a {@link Doc.Break}.
	*
	* @param plusIndent extra indent if taken
	*/
	public final void breakOp(Indent plusIndent) {
	breakOp(Doc.FillMode.UNIFIED, "", plusIndent);
	}

	/** Emit a filled {@link Doc.Break}. */
	public final void breakToFill() {
	breakOp(Doc.FillMode.INDEPENDENT, "", ZERO);
	}

	/** Emit a forced {@link Doc.Break}. */
	public final void forcedBreak() {
	breakOp(Doc.FillMode.FORCED, "", ZERO);
	}

	/**
	* Emit a forced {@link Doc.Break}.
	*
	* @param plusIndent extra indent if taken
	*/
	public final void forcedBreak(Indent plusIndent) {
	breakOp(Doc.FillMode.FORCED, "", plusIndent);
	}

	/**
	* Emit a {@link Doc.Break}, with a specified {@code flat} value (e.g., {@code " "}).
	*
	* @param flat the {@link Doc.Break} when not broken
	*/
	public final void breakOp(String flat) {
	breakOp(Doc.FillMode.UNIFIED, flat, ZERO);
	}

	/**
	* Emit a {@link Doc.Break}, with a specified {@code flat} value (e.g., {@code " "}).
	*
	* @param flat the {@link Doc.Break} when not broken
	*/
	public final void breakToFill(String flat) {
	breakOp(Doc.FillMode.INDEPENDENT, flat, ZERO);
	}

	/**
	* Emit a generic {@link Doc.Break}.
	*
	* @param fillMode the {@link Doc.FillMode}
	* @param flat the {@link Doc.Break} when not broken
	* @param plusIndent extra indent if taken
	*/
	public final void breakOp(Doc.FillMode fillMode, String flat, Indent plusIndent) {
	breakOp(fillMode, flat, plusIndent, /* optionalTag= */ Optional.empty());
	}

	/**
	* Emit a generic {@link Doc.Break}.
	*
	* @param fillMode the {@link Doc.FillMode}
	* @param flat the {@link Doc.Break} when not broken
	* @param plusIndent extra indent if taken
	* @param optionalTag an optional tag for remembering whether the break was taken
	*/
	public final void breakOp(
	Doc.FillMode fillMode, String flat, Indent plusIndent, Optional<BreakTag> optionalTag) {
	add(Doc.Break.make(fillMode, flat, plusIndent, optionalTag));
	}

	private int lastPartialFormatBoundary = -1;

	/**
	* Make the boundary of a region that can be partially formatted. The boundary will be included in
	* the following region, e.g.: [[boundary0, boundary1), [boundary1, boundary2), ...].
	*/
	public void markForPartialFormat() {
	if (lastPartialFormatBoundary == -1) {
	lastPartialFormatBoundary = tokenI;
	return;
	}
	if (tokenI == lastPartialFormatBoundary) {
	return;
	}
	Token start = input.getTokens().get(lastPartialFormatBoundary);
	Token end = input.getTokens().get(tokenI - 1);
	output.markForPartialFormat(start, end);
	lastPartialFormatBoundary = tokenI;
	}

	/**
	* Force or suppress a blank line here in the output.
	*
	* @param wanted whether to force ({@code true}) or suppress {@code false}) the blank line
	*/
	public final void blankLineWanted(BlankLineWanted wanted) {
	output.blankLine(getI(input.getTokens().get(tokenI)), wanted);
	}

	private static int getI(Input.Token token) {
	for (Input.Tok tok : token.getToksBefore()) {
	if (tok.getIndex() >= 0) {
	return tok.getIndex();
	}
	}
	return token.getTok().getIndex();
	}

	private static final Doc.Space SPACE = Doc.Space.make();

	/**
	* Build a list of {@link Op}s from the {@code OpsBuilder}.
	*
	* @return the list of {@link Op}s
	*/
	public final ImmutableList<Op> build() {
	markForPartialFormat();
	// Rewrite the ops to insert comments.
	Multimap<Integer, Op> tokOps = ArrayListMultimap.create();
	int opsN = ops.size();
	for (int i = 0; i < opsN; i++) {
	Op op = ops.get(i);
	if (op instanceof Doc.Token) {
	/*
	* Token ops can have associated non-tokens, including comments, which we need to insert.
	* They can also cause line breaks, so we insert them before or after the current level,
	* when possible.
	*/
	Doc.Token tokenOp = (Doc.Token) op;
	Input.Token token = tokenOp.getToken();
	int j = i; // Where to insert toksBefore before.
	while (0 < j && ops.get(j - 1) instanceof OpenOp) {
	--j;
	}
	int k = i; // Where to insert toksAfter after.
	while (k + 1 < opsN && ops.get(k + 1) instanceof CloseOp) {
	++k;
	}
	if (tokenOp.realOrImaginary().isReal()) {
	/*
	* Regular input token. Copy out toksBefore before token, and toksAfter after it. Insert
	* this token's toksBefore at position j.
	*/
	int newlines = 0; // Count of newlines in a row.
	boolean space = false; // Do we need an extra space after a previous "/*" comment?
	boolean lastWasComment = false; // Was the last thing we output a comment?
	boolean allowBlankAfterLastComment = false;
	for (Input.Tok tokBefore : token.getToksBefore()) {
	if (tokBefore.isNewline()) {
	newlines++;
	} else if (tokBefore.isComment()) {
	tokOps.put(
	j,
	Doc.Break.make(
	tokBefore.isSlashSlashComment() ? Doc.FillMode.FORCED : Doc.FillMode.UNIFIED,
	"",
	tokenOp.getPlusIndentCommentsBefore()));
	tokOps.putAll(j, makeComment(tokBefore));
	space = tokBefore.isSlashStarComment();
	newlines = 0;
	lastWasComment = true;
	if (tokBefore.isJavadocComment()) {
	tokOps.put(j, Doc.Break.makeForced());
	}
	allowBlankAfterLastComment =
	tokBefore.isSlashSlashComment()
	\|\| (tokBefore.isSlashStarComment() && !tokBefore.isJavadocComment());
	}
	}
	if (allowBlankAfterLastComment && newlines > 1) {
	// Force a line break after two newlines in a row following a line or block comment
	output.blankLine(token.getTok().getIndex(), BlankLineWanted.YES);
	}
	if (lastWasComment && newlines > 0) {
	tokOps.put(j, Doc.Break.makeForced());
	} else if (space) {
	tokOps.put(j, SPACE);
	}
	// Now we've seen the Token; output the toksAfter.
	for (Input.Tok tokAfter : token.getToksAfter()) {
	if (tokAfter.isComment()) {
	boolean breakAfter =
	tokAfter.isJavadocComment()
	\|\| (tokAfter.isSlashStarComment()
	&& tokenOp.breakAndIndentTrailingComment().isPresent());
	if (breakAfter) {
	tokOps.put(
	k + 1,
	Doc.Break.make(
	Doc.FillMode.FORCED,
	"",
	tokenOp.breakAndIndentTrailingComment().orElse(Const.ZERO)));
	} else {
	tokOps.put(k + 1, SPACE);
	}
	tokOps.putAll(k + 1, makeComment(tokAfter));
	if (breakAfter) {
	tokOps.put(k + 1, Doc.Break.make(Doc.FillMode.FORCED, "", ZERO));
	}
	}
	}
	} else {
	/*
	* This input token was mistakenly not generated for output. As no whitespace or comments
	* were generated (presumably), copy all input non-tokens literally, even spaces and
	* newlines.
	*/
	int newlines = 0;
	boolean lastWasComment = false;
	for (Input.Tok tokBefore : token.getToksBefore()) {
	if (tokBefore.isNewline()) {
	newlines++;
	} else if (tokBefore.isComment()) {
	newlines = 0;
	lastWasComment = tokBefore.isComment();
	}
	if (lastWasComment && newlines > 0) {
	tokOps.put(j, Doc.Break.makeForced());
	}
	tokOps.put(j, Doc.Tok.make(tokBefore));
	}
	for (Input.Tok tokAfter : token.getToksAfter()) {
	tokOps.put(k + 1, Doc.Tok.make(tokAfter));
	}
	}
	}
	}
	/*
	* Construct new list of ops, splicing in the comments. If a comment is inserted immediately
	* before a space, suppress the space.
	*/
	ImmutableList.Builder<Op> newOps = ImmutableList.builder();
	boolean afterForcedBreak = false; // Was the last Op a forced break? If so, suppress spaces.
	for (int i = 0; i < opsN; i++) {
	for (Op op : tokOps.get(i)) {
	if (!(afterForcedBreak && op instanceof Doc.Space)) {
	newOps.add(op);
	afterForcedBreak = isForcedBreak(op);
	}
	}
	Op op = ops.get(i);
	if (afterForcedBreak
	&& (op instanceof Doc.Space
	\|\| (op instanceof Doc.Break
	&& ((Doc.Break) op).getPlusIndent() == 0
	&& " ".equals(((Doc) op).getFlat())))) {
	continue;
	}
	newOps.add(op);
	if (!(op instanceof OpenOp)) {
	afterForcedBreak = isForcedBreak(op);
	}
	}
	for (Op op : tokOps.get(opsN)) {
	if (!(afterForcedBreak && op instanceof Doc.Space)) {
	newOps.add(op);
	afterForcedBreak = isForcedBreak(op);
	}
	}
	return newOps.build();
	}

	private static boolean isForcedBreak(Op op) {
	return op instanceof Doc.Break && ((Doc.Break) op).isForced();
	}

	private static List<Op> makeComment(Input.Tok comment) {
	return comment.isSlashStarComment()
	? ImmutableList.of(Doc.Tok.make(comment))
	: ImmutableList.of(Doc.Tok.make(comment), Doc.Break.makeForced());
	}

	@Override
	public final String toString() {
	return MoreObjects.toStringHelper(this)
	.add("input", input)
	.add("ops", ops)
	.add("output", output)
	.add("tokenI", tokenI)
	.add("inputPosition", inputPosition)
	.toString();
	}
	}