Reduce the recursion of the extend with "all" keyword to the rplace

part. This is more compatible with the reference implementation.

Author: Horcrux7

src/com/inet/lib/less/LessExtendMap.java

@@ -85,7 +85,7 @@ void add( LessExtend lessExtend, String[] mainSelector ) {
     public String[] concatenateExtends( String[] selectors, boolean isReference ) {
         selectorList.clear();
         for( String selector : selectors ) {
-            concatenateExtendsRecursive( selector, isReference );
+            concatenateExtendsRecursive( selector, isReference, selector );
         }
 
         if( isReference ) {
@@ -114,20 +114,23 @@ public String[] concatenateExtends( String[] selectors, boolean isReference ) {
      *            current selector
      * @param isReference
      *            if the current rule is in a less file which was import with "reference" keyword
+     * @param allSelector
+     *            selector that should match with the "all" keyword. By default is this equals of the selector. Only on
+     *            recursion this is only the replaced part.
      */
-    private void concatenateExtendsRecursive( String selector, boolean isReference ) {
+    private void concatenateExtendsRecursive( String selector, boolean isReference, String allSelector ) {
         List<String[]> list = exact.get( selector );
         if( list != null ) {
             for( String[] lessExtend : list ) {
                 for( String sel : lessExtend ) {
                     boolean needRecursion = selectorList.add( sel );
                     if( needRecursion ) { //only if there are new entries then we need to try a recursion, else we have a stack overflow
-                        concatenateExtendsRecursive( sel, isReference );
+                        concatenateExtendsRecursive( sel, isReference, sel );
                     }
                 }
             }
         }
-        SelectorTokenizer tokenizer = new SelectorTokenizer( selector );
+        SelectorTokenizer tokenizer = new SelectorTokenizer( allSelector );
         do {
             String token = tokenizer.next();
             if( token == null ) {
@@ -142,7 +145,7 @@ private void concatenateExtendsRecursive( String selector, boolean isReference )
                             String replacedSelector = selector.replace( extendingSelector, replace );
                             boolean needRecursion = selectorList.add( replacedSelector );
                             if( needRecursion && !replacedSelector.contains( extendingSelector ) ) {
-                                concatenateExtendsRecursive( replacedSelector, isReference );
+                                concatenateExtendsRecursive( replacedSelector, isReference, replace );
                             }
                         }
                     }

test/com/inet/lib/less/samples/less_org_tests/less/extend.css

@@ -0,0 +1,76 @@
+.error,
+.badError {
+  border: 1px #f00;
+  background: #fdd;
+}
+.error.intrusion,
+.badError.intrusion {
+  font-size: 1.3em;
+  font-weight: bold;
+}
+.intrusion .error,
+.intrusion .badError {
+  display: none;
+}
+.badError {
+  border-width: 3px;
+}
+.foo .bar,
+.foo .baz,
+.ext1 .ext2 .bar,
+.ext3 .bar,
+.ext4 .bar,
+.foo .ext3,
+.foo .ext4,
+.ext1 .ext2 .baz,
+.ext3 .baz,
+.ext4 .baz {
+  display: none;
+}
+div.ext5,
+.ext6 > .ext5,
+div.ext7,
+.ext6 > .ext7 {
+  width: 100px;
+}
+.ext8.ext9,
+.fuu {
+  result: add-foo;
+}
+.ext8 .ext9,
+.ext8 + .ext9,
+.ext8 > .ext9,
+.buu,
+.zap,
+.zoo {
+  result: bar-matched;
+}
+.ext8.nomatch {
+  result: none;
+}
+.ext8 .ext9,
+.buu {
+  result: match-nested-bar;
+}
+.ext8.ext9,
+.fuu {
+  result: match-nested-foo;
+}
+.aa,
+.cc {
+  color: black;
+}
+.aa .dd,
+.aa .ee {
+  background: red;
+}
+.bb,
+.cc,
+.ee,
+.ff {
+  background: red;
+}
+.bb .bb,
+.ff .ff {
+  color: black;
+}

test/com/inet/lib/less/samples/less_org_tests/less/extend.less

@@ -0,0 +1,81 @@
+.error {
+  border: 1px #f00;
+  background: #fdd;
+}
+.error.intrusion {
+  font-size: 1.3em;
+  font-weight: bold;
+}
+.intrusion .error {
+  display: none;
+}
+.badError {
+  &:extend(.error all);
+  border-width: 3px;
+}
+
+.foo .bar, .foo .baz {
+    display: none;
+}
+
+.ext1 .ext2 {
+    &:extend(.foo all);
+}
+
+.ext3,
+.ext4 {
+  &:extend(.foo all);
+  &:extend(.bar all);
+}
+
+div.ext5,
+.ext6 > .ext5 {
+    width: 100px;
+}
+
+.ext7 {
+    &:extend(.ext5 all);
+}
+
+.ext8.ext9 {
+  result: add-foo;
+}
+.ext8 .ext9,
+.ext8 + .ext9,
+.ext8 > .ext9 {
+  result: bar-matched;
+}
+.ext8.nomatch {
+  result: none;
+}
+.ext8 {
+  .ext9 {
+    result: match-nested-bar;
+  }
+}
+.ext8 {
+  &.ext9 {
+    result: match-nested-foo;
+  }
+}
+
+.fuu:extend(.ext8.ext9 all) {}
+.buu:extend(.ext8 .ext9 all) {}
+.zap:extend(.ext8 + .ext9 all) {}
+.zoo:extend(.ext8 > .ext9 all) {}
+
+.aa {
+  color: black;
+  .dd {
+    background: red;
+  }
+}
+.bb {
+  background: red;
+  .bb {
+    color: black;
+  }
+}
+.cc:extend(.aa,.bb) {}
+.ee:extend(.dd all,.bb) {}
+.ff:extend(.dd,.bb all) {}