Java8 Formatting With Block Comments

src/core/fmt/mod.rs

@@ -479,14 +479,22 @@ impl<'parse, Symbol: GrammarSymbol + 'parse> FormatJob<'parse, Symbol> {
         let mut postfix = String::new();
 
         if let Some(injections) = injections_opt {
-            for injection in injections.iter().rev() {
-                let injection_string = self.injection_string(injection, outer_scope);
-
-                match injection.direction {
-                    InjectionAffinity::Left => postfix = format!("{}{}", postfix, injection_string),
-                    InjectionAffinity::Right => prefix = format!("{}{}", injection_string, prefix),
-                }
-            }
+            injections
+                .iter()
+                .filter(|injection| injection.direction == InjectionAffinity::Left)
+                .for_each(|injection| {
+                    let injection_string = self.injection_string(injection, outer_scope);
+                    postfix = format!("{}{}", postfix, injection_string);
+                });
+
+            injections
+                .iter()
+                .filter(|injection| injection.direction == InjectionAffinity::Right)
+                .rev()
+                .for_each(|injection| {
+                    let injection_string = self.injection_string(injection, outer_scope);
+                    prefix = format!("{}{}", injection_string, prefix);
+                });
         }
 
         format!("{}{}{}", prefix, child_string, postfix)

tests/input/java8_block_comments

@@ -0,0 +1,235 @@
+/* Here is where the license goes
+* and here
+    * and here
+     ...
+         ...
+             ...
+                 ...
+                     ...
+                 ...
+             ...
+         ...
+     ...
+ ...
+and now its done.*/
+package com.konjex.util;
+
+/* Something */
+import org.jetbrains.annotations.NotNull; /* Why is there a comment here? */
+
+import java.util.Iterator;
+
+/**
+ Here is some comment about the class
+ It does x, y, z.
+ * For more information see https://www.moreinfo.com/? */
+public class DoublyLinkedList<T> implements Iterable<T> {
+
+    /* Start of the linked list
+     *
+     */
+    private LinkedListNode<T> first;
+    private LinkedListNode<T> last; /* End of the linked list */
+    private int length;
+
+    /* Default constructor */
+    public DoublyLinkedList(){
+        /* No-op */
+    }
+
+    public DoublyLinkedList(){
+        /*
+        No-op
+        */
+    }
+
+    public DoublyLinkedList(){/*
+            * No-op
+            */
+        }
+
+        public DoublyLinkedList(){
+                /* No-op
+                */
+            }
+
+
+    public DoublyLinkedList(){
+        /*
+        No-op
+        */
+
+        /* HERE
+        * BE
+       THERE
+...
+       EVERYWHERE*/
+    }
+
+    public DoublyLinkedList(){/*
+        No-op
+        */
+
+        /* HERE
+        * BE
+       THERE
+...
+       EVERYWHERE*//*
+       BUT WAIT!
+       THERE ARE MORE COMMENTS!!!
+       */
+    }
+
+    public DoublyLinkedList(){
+
+        /*
+         * This lone isolated comment should be compacted!
+        */
+
+    }
+
+    public DoublyLinkedList(){
+
+        /* This lone isolated comment should be compacted! */
+
+    }
+
+    public DoublyLinkedList(
+    T... elements /* This is a strange place for a comment
+    */){
+/* Just add all the elements */
+        for(T element : elements){
+            addLast(element);
+        }
+    }
+
+    public void addFirst(T value){
+        if(isEmpty()){
+            first = new LinkedListNode<>(value, null, null);
+            last = first;
+        }
+        else{
+            LinkedListNode<T> newNode = new LinkedListNode<>(value, null, first);
+            first.setPrev(newNode); /** Append to the front
+            * Then do something else
+            Then do a third thing
+*/
+            first = newNode;
+        }
+        length ++;
+    }
+
+/*
+ * Add an element to the end of the linked list.
+ * Never throws.
+ */
+    public void addLast(T value){
+        if(isEmpty()){
+            first = new LinkedListNode<>(value, null, null);
+            last = first;
+        }
+        /*
+         * Why would there be a comment between these??
+         */
+        else{
+            LinkedListNode<T> newNode = new LinkedListNode<>(value, last, null);
+            last.setNext(newNode);
+            last = newNode;
+        }
+        length ++;
+    }
+
+    public void removeFirst(){
+        if(!removeIfLast()){
+            first = first.getNext();
+            first.setPrev(null);
+        }
+    }
+
+    public void removeLast(){
+        if(!removeIfLast()){
+            last = last.getPrev();
+            last.setNext(null);
+        }
+    }
+
+    /* ----------------------------------------------------------------------
+ HERE IS A LARGE FLOATING COMMENT
+         ---------------------------------------------------------------------- */
+
+    private boolean removeIfLast(){
+
+
+            /* Here is a small floating comment */
+
+        if(isEmpty()){
+            return true;
+        }
+        /* Decrement length */
+        length --;
+        /* Reset first and last pointers if the list is now empty.
+         Return true if this is the case.
+
+         */
+        if(length == 0){
+            first = null;
+            last = null;
+            return true;
+        }
+        return false; /*
+
+         Return false only if there are remaining elements */
+    }
+
+    public boolean isEmpty(){
+        return first == null; /*
+        * Return true if there is no first element */
+    }
+
+    public LinkedListNode<T> getFirst(){
+        return first;
+    }
+
+    public LinkedListNode<T> getLast(){
+        return last;
+    }
+
+    public int size(){
+        return length;
+    }
+
+    @NotNull
+    @Override
+    public Iterator<T> iterator(){
+        return new Iterator<T>(){ /* A */
+            private LinkedListNode<T> currentNode = first;
+
+            @Override
+            public boolean hasNext() {
+                /* Test1 */
+    /* Test2 */
+                return !isEmpty() && currentNode.hasNext();
+            }
+
+            @Override
+            public T next() {
+                T value = currentNode       /* This is a strange place for a comment */
+                            .getValue();
+                currentNode = currentNode
+                                .getNext() /* This place is even stranger */
+                                ;
+                return value;
+            }
+
+            @Override /* This method overrides a method on Iterator
+
+            */
+            public void remove() {
+                /*
+                 * We don't allow element removal via this iterator
+                 */
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+}

tests/input/java8_interface

@@ -1,6 +1,6 @@
 package com.konjex.util.provide;
 
-/**
+/*
  * Object that can be provided by a provider.
  */
 public interface Providable<MatchType> extends DataClass {

tests/input/java8_medium

@@ -3,7 +3,7 @@ package com.konjex.lens.conf;
 import java.io.File;
 import java.util.function.Consumer;
 
-/**
+/*
  * Class for loading lens configuration files by name.
  */
 public abstract class ConfigFileLoader {
@@ -56,4 +56,4 @@ public abstract class ConfigFileLoader {
 
     }
 
-}
+}