diff --git a/java/res/layout/candidate.xml b/java/res/layout/candidate.xml
index 37179d2..03be550 100644
--- a/java/res/layout/candidate.xml
+++ b/java/res/layout/candidate.xml
@@ -23,6 +23,7 @@
     android:layout_width="match_parent"
     android:layout_height="@dimen/candidate_strip_height"
     android:orientation="horizontal"
+    android:paddingRight="12dip"
 >
     <ImageView
         android:id="@+id/candidate_divider"
@@ -44,6 +45,16 @@
         android:focusable="true"
         android:clickable="true"
         android:gravity="center_vertical|center_horizontal"
-        android:paddingLeft="12dip"
-        android:paddingRight="12dip" />
+        android:paddingLeft="12dip" />
+    <TextView
+        android:id="@+id/candidate_debug_info"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:visibility="gone"
+        android:textSize="10dip"
+        android:textColor="#ff808080"
+        android:focusable="false"
+        android:clickable="false"
+        android:gravity="bottom"
+        android:paddingLeft="4dip" />
 </LinearLayout>
diff --git a/java/src/com/android/inputmethod/latin/CandidateView.java b/java/src/com/android/inputmethod/latin/CandidateView.java
index 03ba119..784077a 100644
--- a/java/src/com/android/inputmethod/latin/CandidateView.java
+++ b/java/src/com/android/inputmethod/latin/CandidateView.java
@@ -43,11 +43,9 @@
 import android.widget.TextView;
 
 import java.util.ArrayList;
-import java.util.List;
 
 public class CandidateView extends LinearLayout implements OnClickListener, OnLongClickListener {
     private LatinIME mService;
-    private final ArrayList<CharSequence> mSuggestions = new ArrayList<CharSequence>();
     private final ArrayList<View> mWords = new ArrayList<View>();
 
     private final TextView mPreviewText;
@@ -64,27 +62,12 @@
     private final CharacterStyle mInvertedForegroundColorSpan;
     private final CharacterStyle mInvertedBackgroundColorSpan;
 
-    private boolean mShowingCompletions;
+    private SuggestedWords mSuggestions = SuggestedWords.EMPTY;
     private boolean mShowingAutoCorrectionInverted;
-
     private boolean mShowingAddToDictionary;
 
     private final UiHandler mHandler = new UiHandler();
 
-    private static class UpdateSuggestionsArgs {
-        public final List<CharSequence> mSuggestions;
-        public final boolean mCompletions;
-        public final boolean mTypedWordValid;
-        public final boolean mHaveMinimalSuggestion;
-        public UpdateSuggestionsArgs(List<CharSequence> suggestions, boolean completions,
-                boolean typedWordValid, boolean haveMinimalSuggestion) {
-            mSuggestions = suggestions;
-            mCompletions = completions;
-            mTypedWordValid = typedWordValid;
-            mHaveMinimalSuggestion = haveMinimalSuggestion;
-        }
-    }
-
     private class UiHandler extends Handler {
         private static final int MSG_HIDE_PREVIEW = 0;
         private static final int MSG_UPDATE_SUGGESTION = 1;
@@ -99,9 +82,7 @@
                 hidePreview();
                 break;
             case MSG_UPDATE_SUGGESTION:
-                UpdateSuggestionsArgs args = (UpdateSuggestionsArgs)msg.obj;
-                updateSuggestions(args.mSuggestions, args.mCompletions, args.mTypedWordValid,
-                        args.mHaveMinimalSuggestion);
+                updateSuggestions((SuggestedWords)msg.obj);
                 break;
             }
         }
@@ -115,11 +96,9 @@
             removeMessages(MSG_HIDE_PREVIEW);
         }
 
-        public void postUpdateSuggestions(List<CharSequence> suggestions, boolean completions,
-                boolean typedWordValid, boolean haveMinimalSuggestion) {
+        public void postUpdateSuggestions(SuggestedWords suggestions) {
             cancelUpdateSuggestions();
-            sendMessageDelayed(obtainMessage(MSG_UPDATE_SUGGESTION, new UpdateSuggestionsArgs(
-                    suggestions, completions, typedWordValid, haveMinimalSuggestion)),
+            sendMessageDelayed(obtainMessage(MSG_UPDATE_SUGGESTION, suggestions),
                     DELAY_UPDATE_SUGGESTION);
         }
 
@@ -167,7 +146,7 @@
                 tv.setOnLongClickListener(this);
             ImageView divider = (ImageView)v.findViewById(R.id.candidate_divider);
             // Do not display divider of first candidate.
-            divider.setVisibility(i == 0 ? View.GONE : View.VISIBLE);
+            divider.setVisibility(i == 0 ? GONE : VISIBLE);
             mWords.add(v);
         }
 
@@ -182,44 +161,35 @@
         mService = listener;
     }
 
-    public void setSuggestions(List<CharSequence> suggestions, boolean completions,
-            boolean typedWordValid, boolean haveMinimalSuggestion) {
-        // Don't update suggestions when there is zero or only one suggestion found.
-        if (suggestions != null && suggestions.size() <= 1)
+    public void setSuggestions(SuggestedWords suggestions) {
+        // Don't update suggestions when there is only one suggestion found.
+        // Empty (size zero) suggestions will be passed in order to clear candidate view.
+        if (suggestions == null || suggestions.size() == 1)
             return;
         if (mShowingAutoCorrectionInverted) {
-            mHandler.postUpdateSuggestions(suggestions, completions, typedWordValid,
-                    haveMinimalSuggestion);
+            mHandler.postUpdateSuggestions(suggestions);
         } else {
-            updateSuggestions(suggestions, completions, typedWordValid, haveMinimalSuggestion);
+            updateSuggestions(suggestions);
         }
     }
 
-    private void updateSuggestions(List<CharSequence> suggestions, boolean completions,
-            boolean typedWordValid, boolean haveMinimalSuggestion) {
+    private void updateSuggestions(SuggestedWords suggestions) {
         clear();
-        if (suggestions != null) {
-            int insertCount = Math.min(suggestions.size(), MAX_SUGGESTIONS);
-            for (CharSequence suggestion : suggestions) {
-                mSuggestions.add(suggestion);
-                if (--insertCount == 0)
-                    break;
-            }
-        }
-
-        final int count = mSuggestions.size();
-        boolean existsAutoCompletion = false;
-
+        mSuggestions = suggestions;
+        final int count = suggestions.size();
+        final Object[] debugInfo = suggestions.mDebugInfo;
         for (int i = 0; i < count; i++) {
-            CharSequence suggestion = mSuggestions.get(i);
-            if (suggestion == null) continue;
-            final int wordLength = suggestion.length();
+            CharSequence word = suggestions.getWord(i);
+            if (word == null) continue;
+            final int wordLength = word.length();
 
             final View v = mWords.get(i);
             final TextView tv = (TextView)v.findViewById(R.id.candidate_word);
+            final TextView dv = (TextView)v.findViewById(R.id.candidate_debug_info);
             tv.setTextColor(mColorNormal);
-            if (haveMinimalSuggestion
-                    && ((i == 1 && !typedWordValid) || (i == 0 && typedWordValid))) {
+            if (suggestions.mHasMinimalSuggestion
+                    && ((i == 1 && !suggestions.mTypedWordValid) ||
+                            (i == 0 && suggestions.mTypedWordValid))) {
                 final CharacterStyle style;
                 if (mConfigCandidateHighlightFontColorEnabled) {
                     style = BOLD_SPAN;
@@ -227,10 +197,9 @@
                 } else {
                     style = UNDERLINE_SPAN;
                 }
-                final Spannable word = new SpannableString(suggestion);
-                word.setSpan(style, 0, wordLength, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
-                suggestion = word;
-                existsAutoCompletion = true;
+                final Spannable spannedWord = new SpannableString(word);
+                spannedWord.setSpan(style, 0, wordLength, Spanned.SPAN_INCLUSIVE_EXCLUSIVE);
+                word = spannedWord;
             } else if (i != 0 || (wordLength == 1 && count > 1)) {
                 // HACK: even if i == 0, we use mColorOther when this
                 // suggestion's length is 1
@@ -239,16 +208,18 @@
                 if (mConfigCandidateHighlightFontColorEnabled)
                     tv.setTextColor(mColorOther);
             }
-            tv.setText(suggestion);
+            tv.setText(word);
             tv.setClickable(true);
+            if (debugInfo != null && i < debugInfo.length && debugInfo[i] != null
+                    && !TextUtils.isEmpty(debugInfo[i].toString())) {
+                dv.setText(debugInfo[i].toString());
+                dv.setVisibility(VISIBLE);
+            } else {
+                dv.setVisibility(GONE);
+            }
             addView(v);
         }
 
-        mShowingCompletions = completions;
-        // TODO: Move this call back to LatinIME
-        if (mConfigCandidateHighlightFontColorEnabled)
-            mService.onAutoCompletionStateChanged(existsAutoCompletion);
-
         scrollTo(0, getScrollY());
         requestLayout();
     }
@@ -267,15 +238,19 @@
         mShowingAutoCorrectionInverted = true;
     }
 
+    public boolean isConfigCandidateHighlightFontColorEnabled() {
+        return mConfigCandidateHighlightFontColorEnabled;
+    }
+
     public boolean isShowingAddToDictionaryHint() {
         return mShowingAddToDictionary;
     }
 
     public void showAddToDictionaryHint(CharSequence word) {
-        ArrayList<CharSequence> suggestions = new ArrayList<CharSequence>();
-        suggestions.add(word);
-        suggestions.add(getContext().getText(R.string.hint_add_to_dictionary));
-        setSuggestions(suggestions, false, false, false);
+        SuggestedWords.Builder builder = new SuggestedWords.Builder()
+                .addWord(word)
+                .addWord(getContext().getText(R.string.hint_add_to_dictionary));
+        setSuggestions(builder.build());
         mShowingAddToDictionary = true;
         // Disable R.string.hint_add_to_dictionary button
         TextView tv = (TextView)getChildAt(1).findViewById(R.id.candidate_word);
@@ -288,14 +263,11 @@
         return true;
     }
 
-    /* package */ List<CharSequence> getSuggestions() {
+    public SuggestedWords getSuggestions() {
         return mSuggestions;
     }
 
     public void clear() {
-        // Don't call mSuggestions.clear() because it's being used for logging
-        // in LatinIME.pickSuggestionManually().
-        mSuggestions.clear();
         mShowingAddToDictionary = false;
         mShowingAutoCorrectionInverted = false;
         removeAllViews();
@@ -337,7 +309,7 @@
     @Override
     public boolean onLongClick(View view) {
         int index = (Integer) view.getTag();
-        CharSequence word = mSuggestions.get(index);
+        CharSequence word = mSuggestions.getWord(index);
         if (word.length() < 2)
             return false;
         addToDictionary(word);
@@ -347,12 +319,12 @@
     @Override
     public void onClick(View view) {
         int index = (Integer) view.getTag();
-        CharSequence word = mSuggestions.get(index);
+        CharSequence word = mSuggestions.getWord(index);
         if (mShowingAddToDictionary && index == 0) {
             addToDictionary(word);
         } else {
-            if (!mShowingCompletions) {
-                TextEntryState.acceptedSuggestion(mSuggestions.get(0), word);
+            if (!mSuggestions.mIsApplicationSpecifiedCompletions) {
+                TextEntryState.acceptedSuggestion(mSuggestions.getWord(0), word);
             }
             mService.pickSuggestionManually(index, word);
         }
diff --git a/java/src/com/android/inputmethod/latin/LatinIME.java b/java/src/com/android/inputmethod/latin/LatinIME.java
index 99b6c73..46b735a 100644
--- a/java/src/com/android/inputmethod/latin/LatinIME.java
+++ b/java/src/com/android/inputmethod/latin/LatinIME.java
@@ -77,7 +77,6 @@
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
 import java.util.Locale;
 
 /**
@@ -162,7 +161,7 @@
     // Keep track of the last selection range to decide if we need to show word alternatives
     private int mLastSelectionStart;
     private int mLastSelectionEnd;
-    private List<CharSequence> mSuggestPuncList;
+    private SuggestedWords mSuggestPuncList;
 
     // Input type is such that we should not auto-correct
     private boolean mInputTypeNoAutoCorrect;
@@ -212,7 +211,7 @@
             return mChosenWord;
         }
 
-        public abstract List<CharSequence> getAlternatives();
+        public abstract SuggestedWords.Builder getAlternatives();
     }
 
     public class TypedWordAlternatives extends WordAlternatives {
@@ -233,7 +232,7 @@
         }
 
         @Override
-        public List<CharSequence> getAlternatives() {
+        public SuggestedWords.Builder getAlternatives() {
             return getTypedSuggestions(word);
         }
     }
@@ -655,7 +654,7 @@
         super.onFinishInput();
 
         LatinImeLogger.commit();
-        onAutoCompletionStateChanged(false);
+        mKeyboardSwitcher.onAutoCompletionStateChanged(false);
 
         mVoiceConnector.flushVoiceInputLogs(mConfigurationChanging);
 
@@ -790,7 +789,7 @@
     @Override
     public void hideWindow() {
         LatinImeLogger.commit();
-        onAutoCompletionStateChanged(false);
+        mKeyboardSwitcher.onAutoCompletionStateChanged(false);
 
         if (TRACE) Debug.stopMethodTracing();
         if (mOptionsDialog != null && mOptionsDialog.isShowing()) {
@@ -818,13 +817,12 @@
                 return;
             }
 
-            List<CharSequence> stringList = new ArrayList<CharSequence>();
-            for (int i = 0; i < completions.length; i++) {
-                CompletionInfo ci = completions[i];
-                if (ci != null) stringList.add(ci.getText());
-            }
+            SuggestedWords.Builder builder = new SuggestedWords.Builder()
+                    .setApplicationSpecifiedCompletions(completions)
+                    .setTypedWordValid(true)
+                    .setHasMinimalSuggestion(true);
             // When in fullscreen mode, show completions generated by the application
-            setSuggestions(stringList, true, true, true);
+            setSuggestions(builder.build());
             mBestWord = null;
             setCandidatesViewShown(true);
         }
@@ -1382,7 +1380,7 @@
     }
 
     private boolean isShowingPunctuationList() {
-        return mSuggestPuncList.equals(mCandidateView.getSuggestions());
+        return mSuggestPuncList == mCandidateView.getSuggestions();
     }
 
     private boolean isSuggestionShown() {
@@ -1422,22 +1420,18 @@
     }
 
     public void clearSuggestions() {
-        setSuggestions(null, false, false, false);
+        setSuggestions(SuggestedWords.EMPTY);
     }
 
-    public void setSuggestions(
-            List<CharSequence> suggestions,
-            boolean completions,
-            boolean typedWordValid,
-            boolean haveMinimalSuggestion) {
-
+    public void setSuggestions(SuggestedWords words) {
         if (mVoiceConnector.getAndResetIsShowingHint()) {
              setCandidatesView(mCandidateViewContainer);
         }
 
         if (mCandidateView != null) {
-            mCandidateView.setSuggestions(
-                    suggestions, completions, typedWordValid, haveMinimalSuggestion);
+            mCandidateView.setSuggestions(words);
+            if (mCandidateView.isConfigCandidateHighlightFontColorEnabled())
+                mKeyboardSwitcher.onAutoCompletionStateChanged(words.hasAutoCorrectionWord());
         }
     }
 
@@ -1457,16 +1451,16 @@
         showSuggestions(mWord);
     }
 
-    private List<CharSequence> getTypedSuggestions(WordComposer word) {
-        List<CharSequence> stringList = mSuggest.getSuggestions(
+    private SuggestedWords.Builder getTypedSuggestions(WordComposer word) {
+        return mSuggest.getSuggestedWordBuilder(
                 mKeyboardSwitcher.getInputView(), word, false, null);
-        return stringList;
     }
 
     private void showCorrections(WordAlternatives alternatives) {
         mKeyboardSwitcher.setPreferredLetters(null);
-        List<CharSequence> stringList = alternatives.getAlternatives();
-        showSuggestions(stringList, alternatives.getOriginalWord(), false, false);
+        SuggestedWords.Builder builder = alternatives.getAlternatives();
+        builder.setTypedWordValid(false).setHasMinimalSuggestion(false);
+        showSuggestions(builder.build(), alternatives.getOriginalWord());
     }
 
     private void showSuggestions(WordComposer word) {
@@ -1474,7 +1468,7 @@
         // TODO Maybe need better way of retrieving previous word
         CharSequence prevWord = EditingUtils.getPreviousWord(getCurrentInputConnection(),
                 mWordSeparators);
-        List<CharSequence> stringList = mSuggest.getSuggestions(
+        SuggestedWords.Builder builder = mSuggest.getSuggestedWordBuilder(
                 mKeyboardSwitcher.getInputView(), word, false, prevWord);
         // long stopTime = System.currentTimeMillis(); // TIME MEASUREMENT!
         // Log.d("LatinIME","Suggest Total Time - " + (stopTime - startTime));
@@ -1497,15 +1491,16 @@
         correctionAvailable &= !word.isMostlyCaps();
         correctionAvailable &= !TextEntryState.isCorrecting();
 
-        showSuggestions(stringList, typedWord, typedWordValid, correctionAvailable);
+        builder.setTypedWordValid(typedWordValid).setHasMinimalSuggestion(correctionAvailable);
+        showSuggestions(builder.build(), typedWord);
     }
 
-    private void showSuggestions(List<CharSequence> stringList, CharSequence typedWord,
-            boolean typedWordValid, boolean correctionAvailable) {
-        setSuggestions(stringList, false, typedWordValid, correctionAvailable);
-        if (stringList.size() > 0) {
-            if (correctionAvailable && !typedWordValid && stringList.size() > 1) {
-                mBestWord = stringList.get(1);
+    private void showSuggestions(SuggestedWords suggestedWords, CharSequence typedWord) {
+        setSuggestions(suggestedWords);
+        if (suggestedWords.size() > 0) {
+            if (suggestedWords.mHasMinimalSuggestion
+                    && !suggestedWords.mTypedWordValid && suggestedWords.size() > 1) {
+                mBestWord = suggestedWords.getWord(1);
             } else {
                 mBestWord = typedWord;
             }
@@ -1534,7 +1529,7 @@
     }
 
     public void pickSuggestionManually(int index, CharSequence suggestion) {
-        List<CharSequence> suggestions = mCandidateView.getSuggestions();
+        SuggestedWords suggestions = mCandidateView.getSuggestions();
         mVoiceConnector.flushAndLogAllTextModificationCounters(index, suggestion, mWordSeparators);
 
         final boolean correcting = TextEntryState.isCorrecting();
@@ -1565,7 +1560,7 @@
             // Word separators are suggested before the user inputs something.
             // So, LatinImeLogger logs "" as a user's input.
             LatinImeLogger.logOnManualSuggestion(
-                    "", suggestion.toString(), index, suggestions);
+                    "", suggestion.toString(), index, suggestions.mWords);
             final char primaryCode = suggestion.charAt(0);
             onKey(primaryCode, new int[]{primaryCode}, KeyboardView.NOT_A_TOUCH_COORDINATE,
                     KeyboardView.NOT_A_TOUCH_COORDINATE);
@@ -1583,7 +1578,7 @@
             addToBigramDictionary(suggestion, 1);
         }
         LatinImeLogger.logOnManualSuggestion(mComposing.toString(), suggestion.toString(),
-                index, suggestions);
+                index, suggestions.mWords);
         TextEntryState.acceptedSuggestion(mComposing.toString(), suggestion);
         // Follow it with a space
         if (mAutoSpace && !correcting) {
@@ -1718,7 +1713,7 @@
 
     private void setPunctuationSuggestions() {
         setCandidatesViewShown(isCandidateStripVisible());
-        setSuggestions(mSuggestPuncList, false, false, false);
+        setSuggestions(mSuggestPuncList);
     }
 
     private void addToDictionaries(CharSequence suggestion, int frequencyDelta) {
@@ -2106,13 +2101,17 @@
     }
 
     private void initSuggestPuncList() {
-        mSuggestPuncList = new ArrayList<CharSequence>();
-        mSuggestPuncs = mResources.getString(R.string.suggested_punctuations);
-        if (mSuggestPuncs != null) {
-            for (int i = 0; i < mSuggestPuncs.length(); i++) {
-                mSuggestPuncList.add(mSuggestPuncs.subSequence(i, i + 1));
+        if (mSuggestPuncs != null || mSuggestPuncList != null)
+            return;
+        SuggestedWords.Builder builder = new SuggestedWords.Builder();
+        String puncs = mResources.getString(R.string.suggested_punctuations);
+        if (puncs != null) {
+            for (int i = 0; i < puncs.length(); i++) {
+                builder.addWord(puncs.subSequence(i, i + 1));
             }
         }
+        mSuggestPuncList = builder.build();
+        mSuggestPuncs = puncs;
     }
 
     private boolean isSuggestedPunctuation(int code) {
@@ -2192,10 +2191,6 @@
         System.out.println("CPS = " + ((CPS_BUFFER_SIZE * 1000f) / total));
     }
 
-    public void onAutoCompletionStateChanged(boolean isAutoCompletion) {
-        mKeyboardSwitcher.onAutoCompletionStateChanged(isAutoCompletion);
-    }
-
     @Override
     public void onCurrentInputMethodSubtypeChanged(InputMethodSubtype subtype) {
         SubtypeSwitcher.getInstance().updateSubtype(subtype);
diff --git a/java/src/com/android/inputmethod/latin/Suggest.java b/java/src/com/android/inputmethod/latin/Suggest.java
index a6df187..237d7cb 100644
--- a/java/src/com/android/inputmethod/latin/Suggest.java
+++ b/java/src/com/android/inputmethod/latin/Suggest.java
@@ -25,12 +25,10 @@
 import java.nio.ByteBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
 
 /**
  * This class loads a dictionary and provides a list of suggestions for a given sequence of 
  * characters. This includes corrections and completions.
- * @hide pending API Council Approval
  */
 public class Suggest implements Dictionary.WordCallback {
 
@@ -191,14 +189,21 @@
     }
 
     /**
-     * Returns a list of words that match the list of character codes passed in.
-     * This list will be overwritten the next time this function is called.
+     * Returns a object which represents suggested words that match the list of character codes
+     * passed in. This object contents will be overwritten the next time this function is called.
      * @param view a view for retrieving the context for AutoText
      * @param wordComposer contains what is currently being typed
      * @param prevWordForBigram previous word (used only for bigram)
-     * @return list of suggestions.
+     * @return suggested words object.
      */
-    public List<CharSequence> getSuggestions(View view, WordComposer wordComposer, 
+    public SuggestedWords getSuggestions(View view, WordComposer wordComposer,
+            boolean includeTypedWordIfValid, CharSequence prevWordForBigram) {
+        return getSuggestedWordBuilder(view, wordComposer, includeTypedWordIfValid,
+                prevWordForBigram).build();
+    }
+
+    // TODO: cleanup dictionaries looking up and suggestions building with SuggestedWords.Builder
+    public SuggestedWords.Builder getSuggestedWordBuilder(View view, WordComposer wordComposer,
             boolean includeTypedWordIfValid, CharSequence prevWordForBigram) {
         LatinImeLogger.onStartSuggestion(prevWordForBigram);
         mHaveCorrection = false;
@@ -342,7 +347,7 @@
             }
         }
         removeDupes();
-        return mSuggestions;
+        return new SuggestedWords.Builder().setWords(mSuggestions);
     }
 
     public int[] getNextLettersFrequencies() {
diff --git a/java/src/com/android/inputmethod/latin/SuggestedWords.java b/java/src/com/android/inputmethod/latin/SuggestedWords.java
new file mode 100644
index 0000000..3a3176e
--- /dev/null
+++ b/java/src/com/android/inputmethod/latin/SuggestedWords.java
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * 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.android.inputmethod.latin;
+
+import android.view.inputmethod.CompletionInfo;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class SuggestedWords {
+    public static final SuggestedWords EMPTY = new SuggestedWords(null, false, false, false, null);
+
+    public final List<CharSequence> mWords;
+    public final boolean mIsApplicationSpecifiedCompletions;
+    public final boolean mTypedWordValid;
+    public final boolean mHasMinimalSuggestion;
+    public final Object[] mDebugInfo;
+
+    private SuggestedWords(List<CharSequence> words, boolean isApplicationSpecifiedCompletions,
+            boolean typedWordValid, boolean hasMinamlSuggestion, Object[] debugInfo) {
+        if (words != null) {
+            mWords = words;
+        } else {
+            mWords = Collections.emptyList();
+        }
+        mIsApplicationSpecifiedCompletions = isApplicationSpecifiedCompletions;
+        mTypedWordValid = typedWordValid;
+        mHasMinimalSuggestion = hasMinamlSuggestion;
+        mDebugInfo = debugInfo;
+    }
+
+    public int size() {
+        return mWords.size();
+    }
+
+    public CharSequence getWord(int pos) {
+        return mWords.get(pos);
+    }
+
+    public boolean hasAutoCorrectionWord() {
+        return mHasMinimalSuggestion && ((size() >= 1 && !mTypedWordValid) || mTypedWordValid);
+    }
+
+    public static class Builder {
+        private List<CharSequence> mWords;
+        private boolean mIsCompletions;
+        private boolean mTypedWordVallid;
+        private boolean mHasMinimalSuggestion;
+        private Object[] mDebugInfo;
+
+        public Builder() {
+            // Nothing to do here.
+        }
+
+        public Builder setWords(List<CharSequence> words) {
+            mWords = words;
+            return this;
+        }
+
+        public Builder setDebugInfo(Object[] debuginfo) {
+            mDebugInfo = debuginfo;
+            return this;
+        }
+
+        public Builder addWord(int pos, CharSequence word) {
+            if (mWords == null)
+                mWords = new ArrayList<CharSequence>();
+            mWords.add(pos, word);
+            return this;
+        }
+
+        public Builder addWord(CharSequence word) {
+            if (mWords == null)
+                mWords = new ArrayList<CharSequence>();
+            mWords.add(word);
+            return this;
+        }
+
+        public Builder setApplicationSpecifiedCompletions(CompletionInfo[] infos) {
+            for (CompletionInfo info : infos)
+                addWord(info.getText());
+            mIsCompletions = true;
+            return this;
+        }
+
+        public Builder setTypedWordValid(boolean typedWordValid) {
+            mTypedWordVallid = typedWordValid;
+            return this;
+        }
+
+        public Builder setHasMinimalSuggestion(boolean hasMinamlSuggestion) {
+            mHasMinimalSuggestion = hasMinamlSuggestion;
+            return this;
+        }
+
+        public CharSequence getWord(int pos) {
+            return mWords.get(pos);
+        }
+
+        public SuggestedWords build() {
+            return new SuggestedWords(mWords, mIsCompletions, mTypedWordVallid,
+                    mHasMinimalSuggestion, mDebugInfo);
+        }
+    }
+}
diff --git a/java/src/com/android/inputmethod/voice/VoiceIMEConnector.java b/java/src/com/android/inputmethod/voice/VoiceIMEConnector.java
index 2052d93..c532a0b 100644
--- a/java/src/com/android/inputmethod/voice/VoiceIMEConnector.java
+++ b/java/src/com/android/inputmethod/voice/VoiceIMEConnector.java
@@ -22,6 +22,7 @@
 import com.android.inputmethod.latin.R;
 import com.android.inputmethod.latin.SharedPreferencesCompat;
 import com.android.inputmethod.latin.SubtypeSwitcher;
+import com.android.inputmethod.latin.SuggestedWords;
 
 import android.app.AlertDialog;
 import android.content.Context;
@@ -424,17 +425,20 @@
         if (mWordToSuggestions.containsKey(selectedWord)) {
             mShowingVoiceSuggestions = true;
             List<CharSequence> suggestions = mWordToSuggestions.get(selectedWord);
+            SuggestedWords.Builder builder = new SuggestedWords.Builder();
             // If the first letter of touching is capitalized, make all the suggestions
             // start with a capital letter.
             if (Character.isUpperCase(touching.mWord.charAt(0))) {
-                for (int i = 0; i < suggestions.size(); i++) {
-                    String origSugg = (String) suggestions.get(i);
-                    String capsSugg = origSugg.toUpperCase().charAt(0)
-                            + origSugg.subSequence(1, origSugg.length()).toString();
-                    suggestions.set(i, capsSugg);
+                for (CharSequence word : suggestions) {
+                    String str = word.toString();
+                    word = Character.toUpperCase(str.charAt(0)) + str.substring(1);
+                    builder.addWord(word);
                 }
+            } else {
+                builder.setWords(suggestions);
             }
-            mContext.setSuggestions(suggestions, false, true, true);
+            builder.setTypedWordValid(true).setHasMinimalSuggestion(true);
+            mContext.setSuggestions(builder.build());
             mContext.setCandidatesViewShown(true);
             return true;
         }