Version 1.9.0-dev.8.2

dart/editor/tools/plugins/com.google.dart.tools.ui/src/com/google/dart/tools/ui/internal/text/dart/DartServerProposal.java

 /*
  * Copyright (c) 2014, the Dart project authors.
  * 
  * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html
  * 
  * 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
@@ skipping 235 matching lines @@
         doc.replace(offset, 0, Character.toString(trigger));
         return;
       }
       /*
        * Simplistic argument list completion... strip parens and continue
        */
       // TODO (danrubel) improve argument list completion
       if (completion.startsWith("(")) {
         completion = completion.substring(1, completion.length() - 1);
       }
+      boolean hasArgumentList = completion.endsWith(")");
+      boolean hasArguments = !completion.endsWith("()");
       /*
        * Insert the suggestion
        */
       doc.replace(replacementOffset, replacementLength, completion);
       /*
-       * If the suggestion has parameters, initiate entering parameters
+       * Check if linked mode for arguments is needed
        */
-      if (argumentLengths != null) {
-        // Set up linked position groups for the arguments.
+      boolean isTriggerEnter = trigger == '\0' || trigger == '\n';
+      if (hasArgumentList && (isTriggerEnter || trigger == '(')) {
+        // If Enter or '(' (when blind typing), then use linked mode.
+      } else {
+        // Insert the trigger and stop completion.
+        selectionOffset = completion.length();
+        selectionLength = 0;
+        if (!isTriggerEnter) {
+          doc.replace(
+              replacementOffset + selectionOffset,
+              selectionLength,
+              Character.toString(trigger));
+          ++selectionOffset;
+        }
+        return;
+      }
+      /*
+       * Done if zero arguments and Enter is the trigger
+       */
+      if (!hasArguments && isTriggerEnter) {
+        return;
+      }
+      /*
+       * If the suggestion has an argument list, initiate entering arguments
+       */
+      if (hasArgumentList) {
+        // Prepare linked mode model
         LinkedModeModel model = new LinkedModeModel();
-        buildLinkedModeModel(model, doc, replacementOffset);
+        if (hasArguments) {
+          buildLinkedModeModel_hasArgumentList(model, doc, replacementOffset);
+        } else {
+          // If there are no arguments, we still want to use linked mode to ignore ')'.
+          buildLinkedModeModel_emptyArguments(model, doc, replacementOffset, completion);
+        }
         model.forceInstall();
-
+        // Start linked mode UI
         LinkedModeUI ui = new EditorLinkedModeUI(model, viewer);
-        ui.setExitPolicy(new ExitPolicy(')', doc, viewer));
+        if (hasArguments) {
+          ui.setExitPolicy(new ExitPolicy(')', doc, viewer));
+        } else {
+          ui.setExitPolicy(new AnyExitPolicy());
+        }
         ui.setExitPosition(viewer, replacementOffset + completion.length(), 0, Integer.MAX_VALUE);
         ui.setCyclingMode(LinkedModeUI.CYCLE_WHEN_NO_PARENT);
         ui.enter();
-        return;
-      }
-      /*
-       * If completion already includes '()' then don't insert extra '(' or ')'
-       */
-      if (completion.endsWith(")") && (trigger == '(' || trigger == ')')) {
-        return;
-      }
-      /*
-       * Insert the trigger character typed if it is not enter or null
-       */
-      if (trigger != '\0' && trigger != '\n') {
-        doc.replace(
-            replacementOffset + selectionOffset,
-            selectionLength,
-            Character.toString(trigger));
-        ++selectionOffset;
-        selectionLength = 0;
-        return;
       }
     } catch (BadLocationException e) {
       DartCore.logInformation("Failed to replace offset:" + replacementOffset + " length:"
           + replacementLength + " with:" + completion, e);
       instrumentation.metric("Problem", "BadLocationException");
     } finally {
       instrumentation.log();
     }
   }
 
@@ skipping 170 matching lines @@
     try {
       textEntered = document.get(replacementOffset, offset - replacementOffset);
     } catch (BadLocationException x) {
       return false;
     }
     String completion = TextProcessor.deprocess(getDisplayString());
     if (completion.length() == 0 || completion.length() < textEntered.length()) {
       return false;
     }
     // If the user has entered an upper case char as the first char
-    // then filter all lower case first character suggestions.
-    if (Character.isUpperCase(textEntered.charAt(0)) && Character.isLowerCase(completion.charAt(0))) {
-      return false;
-    }
-    String partialCompletion = completion.substring(0, textEntered.length());
-    if (partialCompletion.equalsIgnoreCase(textEntered)) {
-      return true;
+    // then filter using only camelCaseMatching
+    if (!Character.isUpperCase(textEntered.charAt(0))) {
+      String partialCompletion = completion.substring(0, textEntered.length());
+      if (partialCompletion.equalsIgnoreCase(textEntered)) {
+        return true;
+      }
     }
     char[] pattern = textEntered.toCharArray();
     char[] name = completion.toCharArray();
     return CharOperation.camelCaseMatch(pattern, 0, pattern.length, name, 0, name.length, false);
   }
 
-  protected void buildLinkedModeModel(LinkedModeModel model, IDocument document, int baseOffset)
-      throws BadLocationException {
+  protected void buildLinkedModeModel_emptyArguments(LinkedModeModel model, IDocument document,
+      int baseOffset, String completion) throws BadLocationException {
+    LinkedPositionGroup group = new LinkedPositionGroup();
+    LinkedPosition pos = new LinkedPosition(
+        document,
+        baseOffset + completion.length(),
+        0,
+        LinkedPositionGroup.NO_STOP);
+    group.addPosition(pos);
+    model.addGroup(group);
+  }
+
+  protected void buildLinkedModeModel_hasArgumentList(LinkedModeModel model, IDocument document,
+      int baseOffset) throws BadLocationException {
     // TODO(paulberry): consider extending to support optional arguments, as
     // FilledArgumentNamesMethodProposal does.
     for (int i = 0; i != argumentOffsets.length; i++) {
       LinkedPositionGroup group = new LinkedPositionGroup();
       LinkedPosition pos = new LinkedPosition(
           document,
           baseOffset + argumentOffsets[i],
           argumentLengths[i],
           LinkedPositionGroup.NO_STOP);
       group.addPosition(pos);
@@ skipping 161 matching lines @@
         if (element != null) {
           return element.getParameters();
         }
       }
     }
     return null;
   }
 }
 
 /**
+ * {@link IExitPolicy} that exists on any character.
+ */
+class AnyExitPolicy implements IExitPolicy {
+  @Override
+  public ExitFlags doExit(LinkedModeModel environment, VerifyEvent event, int offset, int length) {
+    if (event.character == 0) {
+      return null;
+    }
+    boolean doit = event.character != ')';
+    return new ExitFlags(ILinkedModeListener.UPDATE_CARET, doit);
+  }
+}
+
+/**
  * Allow the linked mode editor to continue running even when the exit character is typed as part of
  * a function argument. Using shift operators in a context that expects balanced angle brackets is
  * not legal syntax and will confuse the linked mode editor.
  */
 class ExitPolicy implements IExitPolicy {
 
   private int parenCount = 0;
   private int braceCount = 0;
   private int bracketCount = 0;
   private int angleBracketCount = 0;
   private char lastChar = (char) 0;
 
-  final char exitChar;
+  private final char exitChar;
   private final IDocument document;
   private final ITextViewer viewer;
 
   public ExitPolicy(char exitChar, IDocument document, ITextViewer viewer) {
     this.exitChar = exitChar;
     this.document = document;
     this.viewer = viewer;
   }
 
   @Override
@@ skipping 121 matching lines @@
         return braceCount == -1;
       case ']':
         return bracketCount == -1;
       case '>':
         return angleBracketCount == -1;
       default:
         return true; // never unbalanced
     }
   }
 }