(OtherTreeNode.class, this, IndentationAwareUiTestLanguagePackage.CHILD_LIST__CHILDREN);
+ }
+ return children;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.CHILD_LIST__CHILDREN:
+ return ((InternalEList>)getChildren()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.CHILD_LIST__CHILDREN:
+ return getChildren();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.CHILD_LIST__CHILDREN:
+ getChildren().clear();
+ getChildren().addAll((Collection extends OtherTreeNode>)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.CHILD_LIST__CHILDREN:
+ getChildren().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.CHILD_LIST__CHILDREN:
+ return children != null && !children.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //ChildListImpl
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/IndentationAwareUiTestLanguageFactoryImpl.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/IndentationAwareUiTestLanguageFactoryImpl.java
new file mode 100644
index 0000000000..621d907b85
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/IndentationAwareUiTestLanguageFactoryImpl.java
@@ -0,0 +1,147 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.*;
+
+/**
+ *
+ * An implementation of the model Factory.
+ *
+ * @generated
+ */
+public class IndentationAwareUiTestLanguageFactoryImpl extends EFactoryImpl implements IndentationAwareUiTestLanguageFactory
+{
+ /**
+ * Creates the default factory implementation.
+ *
+ *
+ * @generated
+ */
+ public static IndentationAwareUiTestLanguageFactory init()
+ {
+ try
+ {
+ IndentationAwareUiTestLanguageFactory theIndentationAwareUiTestLanguageFactory = (IndentationAwareUiTestLanguageFactory)EPackage.Registry.INSTANCE.getEFactory(IndentationAwareUiTestLanguagePackage.eNS_URI);
+ if (theIndentationAwareUiTestLanguageFactory != null)
+ {
+ return theIndentationAwareUiTestLanguageFactory;
+ }
+ }
+ catch (Exception exception)
+ {
+ EcorePlugin.INSTANCE.log(exception);
+ }
+ return new IndentationAwareUiTestLanguageFactoryImpl();
+ }
+
+ /**
+ * Creates an instance of the factory.
+ *
+ *
+ * @generated
+ */
+ public IndentationAwareUiTestLanguageFactoryImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public EObject create(EClass eClass)
+ {
+ switch (eClass.getClassifierID())
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE: return createTree();
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE: return createTreeNode();
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE: return createOtherTreeNode();
+ case IndentationAwareUiTestLanguagePackage.CHILD_LIST: return createChildList();
+ default:
+ throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+ }
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public Tree createTree()
+ {
+ TreeImpl tree = new TreeImpl();
+ return tree;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public TreeNode createTreeNode()
+ {
+ TreeNodeImpl treeNode = new TreeNodeImpl();
+ return treeNode;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public OtherTreeNode createOtherTreeNode()
+ {
+ OtherTreeNodeImpl otherTreeNode = new OtherTreeNodeImpl();
+ return otherTreeNode;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ChildList createChildList()
+ {
+ ChildListImpl childList = new ChildListImpl();
+ return childList;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public IndentationAwareUiTestLanguagePackage getIndentationAwareUiTestLanguagePackage()
+ {
+ return (IndentationAwareUiTestLanguagePackage)getEPackage();
+ }
+
+ /**
+ *
+ *
+ * @deprecated
+ * @generated
+ */
+ @Deprecated
+ public static IndentationAwareUiTestLanguagePackage getPackage()
+ {
+ return IndentationAwareUiTestLanguagePackage.eINSTANCE;
+ }
+
+} //IndentationAwareUiTestLanguageFactoryImpl
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/IndentationAwareUiTestLanguagePackageImpl.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/IndentationAwareUiTestLanguagePackageImpl.java
new file mode 100644
index 0000000000..d961f6b3fe
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/IndentationAwareUiTestLanguagePackageImpl.java
@@ -0,0 +1,329 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EReference;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.ChildList;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.IndentationAwareUiTestLanguageFactory;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.IndentationAwareUiTestLanguagePackage;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.OtherTreeNode;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.Tree;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.TreeNode;
+
+/**
+ *
+ * An implementation of the model Package.
+ *
+ * @generated
+ */
+public class IndentationAwareUiTestLanguagePackageImpl extends EPackageImpl implements IndentationAwareUiTestLanguagePackage
+{
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass treeEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass treeNodeEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass otherTreeNodeEClass = null;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private EClass childListEClass = null;
+
+ /**
+ * Creates an instance of the model Package, registered with
+ * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+ * package URI value.
+ * Note: the correct way to create the package is via the static
+ * factory method {@link #init init()}, which also performs
+ * initialization of the package, or returns the registered package,
+ * if one already exists.
+ *
+ *
+ * @see org.eclipse.emf.ecore.EPackage.Registry
+ * @see org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.IndentationAwareUiTestLanguagePackage#eNS_URI
+ * @see #init()
+ * @generated
+ */
+ private IndentationAwareUiTestLanguagePackageImpl()
+ {
+ super(eNS_URI, IndentationAwareUiTestLanguageFactory.eINSTANCE);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private static boolean isInited = false;
+
+ /**
+ * Creates, registers, and initializes the Package for this model, and for any others upon which it depends.
+ *
+ *
This method is used to initialize {@link IndentationAwareUiTestLanguagePackage#eINSTANCE} when that field is accessed.
+ * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
+ *
+ *
+ * @see #eNS_URI
+ * @see #createPackageContents()
+ * @see #initializePackageContents()
+ * @generated
+ */
+ public static IndentationAwareUiTestLanguagePackage init()
+ {
+ if (isInited) return (IndentationAwareUiTestLanguagePackage)EPackage.Registry.INSTANCE.getEPackage(IndentationAwareUiTestLanguagePackage.eNS_URI);
+
+ // Obtain or create and register package
+ IndentationAwareUiTestLanguagePackageImpl theIndentationAwareUiTestLanguagePackage = (IndentationAwareUiTestLanguagePackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof IndentationAwareUiTestLanguagePackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new IndentationAwareUiTestLanguagePackageImpl());
+
+ isInited = true;
+
+ // Create package meta-data objects
+ theIndentationAwareUiTestLanguagePackage.createPackageContents();
+
+ // Initialize created meta-data
+ theIndentationAwareUiTestLanguagePackage.initializePackageContents();
+
+ // Mark meta-data to indicate it can't be changed
+ theIndentationAwareUiTestLanguagePackage.freeze();
+
+
+ // Update the registry and return the package
+ EPackage.Registry.INSTANCE.put(IndentationAwareUiTestLanguagePackage.eNS_URI, theIndentationAwareUiTestLanguagePackage);
+ return theIndentationAwareUiTestLanguagePackage;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getTree()
+ {
+ return treeEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTree_Nodes()
+ {
+ return (EReference)treeEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTree_MoreNodes()
+ {
+ return (EReference)treeEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getTreeNode()
+ {
+ return treeNodeEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getTreeNode_Name()
+ {
+ return (EAttribute)treeNodeEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getTreeNode_Children()
+ {
+ return (EReference)treeNodeEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getOtherTreeNode()
+ {
+ return otherTreeNodeEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EAttribute getOtherTreeNode_Name()
+ {
+ return (EAttribute)otherTreeNodeEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getOtherTreeNode_ChildList()
+ {
+ return (EReference)otherTreeNodeEClass.getEStructuralFeatures().get(1);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EClass getChildList()
+ {
+ return childListEClass;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EReference getChildList_Children()
+ {
+ return (EReference)childListEClass.getEStructuralFeatures().get(0);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public IndentationAwareUiTestLanguageFactory getIndentationAwareUiTestLanguageFactory()
+ {
+ return (IndentationAwareUiTestLanguageFactory)getEFactoryInstance();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private boolean isCreated = false;
+
+ /**
+ * Creates the meta-model objects for the package. This method is
+ * guarded to have no affect on any invocation but its first.
+ *
+ *
+ * @generated
+ */
+ public void createPackageContents()
+ {
+ if (isCreated) return;
+ isCreated = true;
+
+ // Create classes and their features
+ treeEClass = createEClass(TREE);
+ createEReference(treeEClass, TREE__NODES);
+ createEReference(treeEClass, TREE__MORE_NODES);
+
+ treeNodeEClass = createEClass(TREE_NODE);
+ createEAttribute(treeNodeEClass, TREE_NODE__NAME);
+ createEReference(treeNodeEClass, TREE_NODE__CHILDREN);
+
+ otherTreeNodeEClass = createEClass(OTHER_TREE_NODE);
+ createEAttribute(otherTreeNodeEClass, OTHER_TREE_NODE__NAME);
+ createEReference(otherTreeNodeEClass, OTHER_TREE_NODE__CHILD_LIST);
+
+ childListEClass = createEClass(CHILD_LIST);
+ createEReference(childListEClass, CHILD_LIST__CHILDREN);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ private boolean isInitialized = false;
+
+ /**
+ * Complete the initialization of the package and its meta-model. This
+ * method is guarded to have no affect on any invocation but its first.
+ *
+ *
+ * @generated
+ */
+ public void initializePackageContents()
+ {
+ if (isInitialized) return;
+ isInitialized = true;
+
+ // Initialize package
+ setName(eNAME);
+ setNsPrefix(eNS_PREFIX);
+ setNsURI(eNS_URI);
+
+ // Create type parameters
+
+ // Set bounds for type parameters
+
+ // Add supertypes to classes
+
+ // Initialize classes and features; add operations and parameters
+ initEClass(treeEClass, Tree.class, "Tree", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getTree_Nodes(), this.getTreeNode(), null, "nodes", null, 0, -1, Tree.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTree_MoreNodes(), this.getOtherTreeNode(), null, "moreNodes", null, 0, -1, Tree.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(treeNodeEClass, TreeNode.class, "TreeNode", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getTreeNode_Name(), ecorePackage.getEString(), "name", null, 0, 1, TreeNode.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getTreeNode_Children(), this.getTreeNode(), null, "children", null, 0, -1, TreeNode.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(otherTreeNodeEClass, OtherTreeNode.class, "OtherTreeNode", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEAttribute(getOtherTreeNode_Name(), ecorePackage.getEString(), "name", null, 0, 1, OtherTreeNode.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+ initEReference(getOtherTreeNode_ChildList(), this.getChildList(), null, "childList", null, 0, 1, OtherTreeNode.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ initEClass(childListEClass, ChildList.class, "ChildList", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+ initEReference(getChildList_Children(), this.getOtherTreeNode(), null, "children", null, 0, -1, ChildList.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+ // Create resource
+ createResource(eNS_URI);
+ }
+
+} //IndentationAwareUiTestLanguagePackageImpl
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/OtherTreeNodeImpl.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/OtherTreeNodeImpl.java
new file mode 100644
index 0000000000..3b4f09c5b5
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/OtherTreeNodeImpl.java
@@ -0,0 +1,270 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.ChildList;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.IndentationAwareUiTestLanguagePackage;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.OtherTreeNode;
+
+/**
+ *
+ * An implementation of the model object 'Other Tree Node'.
+ *
+ *
+ * The following features are implemented:
+ *
+ *
+ * - {@link org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl.OtherTreeNodeImpl#getName Name}
+ * - {@link org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl.OtherTreeNodeImpl#getChildList Child List}
+ *
+ *
+ * @generated
+ */
+public class OtherTreeNodeImpl extends MinimalEObjectImpl.Container implements OtherTreeNode
+{
+ /**
+ * The default value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected static final String NAME_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected String name = NAME_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getChildList() Child List}' containment reference.
+ *
+ *
+ * @see #getChildList()
+ * @generated
+ * @ordered
+ */
+ protected ChildList childList;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected OtherTreeNodeImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return IndentationAwareUiTestLanguagePackage.Literals.OTHER_TREE_NODE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(String newName)
+ {
+ String oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__NAME, oldName, name));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public ChildList getChildList()
+ {
+ return childList;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public NotificationChain basicSetChildList(ChildList newChildList, NotificationChain msgs)
+ {
+ ChildList oldChildList = childList;
+ childList = newChildList;
+ if (eNotificationRequired())
+ {
+ ENotificationImpl notification = new ENotificationImpl(this, Notification.SET, IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__CHILD_LIST, oldChildList, newChildList);
+ if (msgs == null) msgs = notification; else msgs.add(notification);
+ }
+ return msgs;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setChildList(ChildList newChildList)
+ {
+ if (newChildList != childList)
+ {
+ NotificationChain msgs = null;
+ if (childList != null)
+ msgs = ((InternalEObject)childList).eInverseRemove(this, EOPPOSITE_FEATURE_BASE - IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__CHILD_LIST, null, msgs);
+ if (newChildList != null)
+ msgs = ((InternalEObject)newChildList).eInverseAdd(this, EOPPOSITE_FEATURE_BASE - IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__CHILD_LIST, null, msgs);
+ msgs = basicSetChildList(newChildList, msgs);
+ if (msgs != null) msgs.dispatch();
+ }
+ else if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__CHILD_LIST, newChildList, newChildList));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__CHILD_LIST:
+ return basicSetChildList(null, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__NAME:
+ return getName();
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__CHILD_LIST:
+ return getChildList();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__NAME:
+ setName((String)newValue);
+ return;
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__CHILD_LIST:
+ setChildList((ChildList)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__NAME:
+ setName(NAME_EDEFAULT);
+ return;
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__CHILD_LIST:
+ setChildList((ChildList)null);
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__NAME:
+ return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE__CHILD_LIST:
+ return childList != null;
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (name: ");
+ result.append(name);
+ result.append(')');
+ return result.toString();
+ }
+
+} //OtherTreeNodeImpl
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/TreeImpl.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/TreeImpl.java
new file mode 100644
index 0000000000..8067793131
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/TreeImpl.java
@@ -0,0 +1,211 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.IndentationAwareUiTestLanguagePackage;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.OtherTreeNode;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.Tree;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.TreeNode;
+
+/**
+ *
+ * An implementation of the model object 'Tree'.
+ *
+ *
+ * The following features are implemented:
+ *
+ *
+ * - {@link org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl.TreeImpl#getNodes Nodes}
+ * - {@link org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl.TreeImpl#getMoreNodes More Nodes}
+ *
+ *
+ * @generated
+ */
+public class TreeImpl extends MinimalEObjectImpl.Container implements Tree
+{
+ /**
+ * The cached value of the '{@link #getNodes() Nodes}' containment reference list.
+ *
+ *
+ * @see #getNodes()
+ * @generated
+ * @ordered
+ */
+ protected EList nodes;
+
+ /**
+ * The cached value of the '{@link #getMoreNodes() More Nodes}' containment reference list.
+ *
+ *
+ * @see #getMoreNodes()
+ * @generated
+ * @ordered
+ */
+ protected EList moreNodes;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected TreeImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return IndentationAwareUiTestLanguagePackage.Literals.TREE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getNodes()
+ {
+ if (nodes == null)
+ {
+ nodes = new EObjectContainmentEList(TreeNode.class, this, IndentationAwareUiTestLanguagePackage.TREE__NODES);
+ }
+ return nodes;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getMoreNodes()
+ {
+ if (moreNodes == null)
+ {
+ moreNodes = new EObjectContainmentEList(OtherTreeNode.class, this, IndentationAwareUiTestLanguagePackage.TREE__MORE_NODES);
+ }
+ return moreNodes;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE__NODES:
+ return ((InternalEList>)getNodes()).basicRemove(otherEnd, msgs);
+ case IndentationAwareUiTestLanguagePackage.TREE__MORE_NODES:
+ return ((InternalEList>)getMoreNodes()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE__NODES:
+ return getNodes();
+ case IndentationAwareUiTestLanguagePackage.TREE__MORE_NODES:
+ return getMoreNodes();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE__NODES:
+ getNodes().clear();
+ getNodes().addAll((Collection extends TreeNode>)newValue);
+ return;
+ case IndentationAwareUiTestLanguagePackage.TREE__MORE_NODES:
+ getMoreNodes().clear();
+ getMoreNodes().addAll((Collection extends OtherTreeNode>)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE__NODES:
+ getNodes().clear();
+ return;
+ case IndentationAwareUiTestLanguagePackage.TREE__MORE_NODES:
+ getMoreNodes().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE__NODES:
+ return nodes != null && !nodes.isEmpty();
+ case IndentationAwareUiTestLanguagePackage.TREE__MORE_NODES:
+ return moreNodes != null && !moreNodes.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+} //TreeImpl
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/TreeNodeImpl.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/TreeNodeImpl.java
new file mode 100644
index 0000000000..34ace1f61e
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/impl/TreeNodeImpl.java
@@ -0,0 +1,244 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl;
+
+import java.util.Collection;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.NotificationChain;
+
+import org.eclipse.emf.common.util.EList;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.InternalEObject;
+
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.impl.MinimalEObjectImpl;
+
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.emf.ecore.util.InternalEList;
+
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.IndentationAwareUiTestLanguagePackage;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.TreeNode;
+
+/**
+ *
+ * An implementation of the model object 'Tree Node'.
+ *
+ *
+ * The following features are implemented:
+ *
+ *
+ * - {@link org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl.TreeNodeImpl#getName Name}
+ * - {@link org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.impl.TreeNodeImpl#getChildren Children}
+ *
+ *
+ * @generated
+ */
+public class TreeNodeImpl extends MinimalEObjectImpl.Container implements TreeNode
+{
+ /**
+ * The default value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected static final String NAME_EDEFAULT = null;
+
+ /**
+ * The cached value of the '{@link #getName() Name}' attribute.
+ *
+ *
+ * @see #getName()
+ * @generated
+ * @ordered
+ */
+ protected String name = NAME_EDEFAULT;
+
+ /**
+ * The cached value of the '{@link #getChildren() Children}' containment reference list.
+ *
+ *
+ * @see #getChildren()
+ * @generated
+ * @ordered
+ */
+ protected EList children;
+
+ /**
+ *
+ *
+ * @generated
+ */
+ protected TreeNodeImpl()
+ {
+ super();
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ protected EClass eStaticClass()
+ {
+ return IndentationAwareUiTestLanguagePackage.Literals.TREE_NODE;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public String getName()
+ {
+ return name;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public void setName(String newName)
+ {
+ String oldName = name;
+ name = newName;
+ if (eNotificationRequired())
+ eNotify(new ENotificationImpl(this, Notification.SET, IndentationAwareUiTestLanguagePackage.TREE_NODE__NAME, oldName, name));
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ public EList getChildren()
+ {
+ if (children == null)
+ {
+ children = new EObjectContainmentEList(TreeNode.class, this, IndentationAwareUiTestLanguagePackage.TREE_NODE__CHILDREN);
+ }
+ return children;
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public NotificationChain eInverseRemove(InternalEObject otherEnd, int featureID, NotificationChain msgs)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE__CHILDREN:
+ return ((InternalEList>)getChildren()).basicRemove(otherEnd, msgs);
+ }
+ return super.eInverseRemove(otherEnd, featureID, msgs);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public Object eGet(int featureID, boolean resolve, boolean coreType)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE__NAME:
+ return getName();
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE__CHILDREN:
+ return getChildren();
+ }
+ return super.eGet(featureID, resolve, coreType);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @SuppressWarnings("unchecked")
+ @Override
+ public void eSet(int featureID, Object newValue)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE__NAME:
+ setName((String)newValue);
+ return;
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE__CHILDREN:
+ getChildren().clear();
+ getChildren().addAll((Collection extends TreeNode>)newValue);
+ return;
+ }
+ super.eSet(featureID, newValue);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public void eUnset(int featureID)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE__NAME:
+ setName(NAME_EDEFAULT);
+ return;
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE__CHILDREN:
+ getChildren().clear();
+ return;
+ }
+ super.eUnset(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public boolean eIsSet(int featureID)
+ {
+ switch (featureID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE__NAME:
+ return NAME_EDEFAULT == null ? name != null : !NAME_EDEFAULT.equals(name);
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE__CHILDREN:
+ return children != null && !children.isEmpty();
+ }
+ return super.eIsSet(featureID);
+ }
+
+ /**
+ *
+ *
+ * @generated
+ */
+ @Override
+ public String toString()
+ {
+ if (eIsProxy()) return super.toString();
+
+ StringBuffer result = new StringBuffer(super.toString());
+ result.append(" (name: ");
+ result.append(name);
+ result.append(')');
+ return result.toString();
+ }
+
+} //TreeNodeImpl
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/util/IndentationAwareUiTestLanguageAdapterFactory.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/util/IndentationAwareUiTestLanguageAdapterFactory.java
new file mode 100644
index 0000000000..d56a626a2a
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/util/IndentationAwareUiTestLanguageAdapterFactory.java
@@ -0,0 +1,197 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.util;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.*;
+
+/**
+ *
+ * The Adapter Factory for the model.
+ * It provides an adapter createXXX
method for each class of the model.
+ *
+ * @see org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.IndentationAwareUiTestLanguagePackage
+ * @generated
+ */
+public class IndentationAwareUiTestLanguageAdapterFactory extends AdapterFactoryImpl
+{
+ /**
+ * The cached model package.
+ *
+ *
+ * @generated
+ */
+ protected static IndentationAwareUiTestLanguagePackage modelPackage;
+
+ /**
+ * Creates an instance of the adapter factory.
+ *
+ *
+ * @generated
+ */
+ public IndentationAwareUiTestLanguageAdapterFactory()
+ {
+ if (modelPackage == null)
+ {
+ modelPackage = IndentationAwareUiTestLanguagePackage.eINSTANCE;
+ }
+ }
+
+ /**
+ * Returns whether this factory is applicable for the type of the object.
+ *
+ * This implementation returns true
if the object is either the model's package or is an instance object of the model.
+ *
+ * @return whether this factory is applicable for the type of the object.
+ * @generated
+ */
+ @Override
+ public boolean isFactoryForType(Object object)
+ {
+ if (object == modelPackage)
+ {
+ return true;
+ }
+ if (object instanceof EObject)
+ {
+ return ((EObject)object).eClass().getEPackage() == modelPackage;
+ }
+ return false;
+ }
+
+ /**
+ * The switch that delegates to the createXXX
methods.
+ *
+ *
+ * @generated
+ */
+ protected IndentationAwareUiTestLanguageSwitch modelSwitch =
+ new IndentationAwareUiTestLanguageSwitch()
+ {
+ @Override
+ public Adapter caseTree(Tree object)
+ {
+ return createTreeAdapter();
+ }
+ @Override
+ public Adapter caseTreeNode(TreeNode object)
+ {
+ return createTreeNodeAdapter();
+ }
+ @Override
+ public Adapter caseOtherTreeNode(OtherTreeNode object)
+ {
+ return createOtherTreeNodeAdapter();
+ }
+ @Override
+ public Adapter caseChildList(ChildList object)
+ {
+ return createChildListAdapter();
+ }
+ @Override
+ public Adapter defaultCase(EObject object)
+ {
+ return createEObjectAdapter();
+ }
+ };
+
+ /**
+ * Creates an adapter for the target
.
+ *
+ *
+ * @param target the object to adapt.
+ * @return the adapter for the target
.
+ * @generated
+ */
+ @Override
+ public Adapter createAdapter(Notifier target)
+ {
+ return modelSwitch.doSwitch((EObject)target);
+ }
+
+
+ /**
+ * Creates a new adapter for an object of class '{@link org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.Tree Tree}'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.Tree
+ * @generated
+ */
+ public Adapter createTreeAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.TreeNode Tree Node}'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.TreeNode
+ * @generated
+ */
+ public Adapter createTreeNodeAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.OtherTreeNode Other Tree Node}'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.OtherTreeNode
+ * @generated
+ */
+ public Adapter createOtherTreeNodeAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for an object of class '{@link org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.ChildList Child List}'.
+ *
+ * This default implementation returns null so that we can easily ignore cases;
+ * it's useful to ignore a case when inheritance will catch all the cases anyway.
+ *
+ * @return the new adapter.
+ * @see org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.ChildList
+ * @generated
+ */
+ public Adapter createChildListAdapter()
+ {
+ return null;
+ }
+
+ /**
+ * Creates a new adapter for the default case.
+ *
+ * This default implementation returns null.
+ *
+ * @return the new adapter.
+ * @generated
+ */
+ public Adapter createEObjectAdapter()
+ {
+ return null;
+ }
+
+} //IndentationAwareUiTestLanguageAdapterFactory
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/util/IndentationAwareUiTestLanguageSwitch.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/util/IndentationAwareUiTestLanguageSwitch.java
new file mode 100644
index 0000000000..f9c83df398
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/indentationAwareUiTestLanguage/util/IndentationAwareUiTestLanguageSwitch.java
@@ -0,0 +1,193 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.*;
+
+/**
+ *
+ * The Switch for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the caseXXX
method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ *
+ * @see org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.IndentationAwareUiTestLanguagePackage
+ * @generated
+ */
+public class IndentationAwareUiTestLanguageSwitch extends Switch
+{
+ /**
+ * The cached model package
+ *
+ *
+ * @generated
+ */
+ protected static IndentationAwareUiTestLanguagePackage modelPackage;
+
+ /**
+ * Creates an instance of the switch.
+ *
+ *
+ * @generated
+ */
+ public IndentationAwareUiTestLanguageSwitch()
+ {
+ if (modelPackage == null)
+ {
+ modelPackage = IndentationAwareUiTestLanguagePackage.eINSTANCE;
+ }
+ }
+
+ /**
+ * Checks whether this is a switch for the given package.
+ *
+ *
+ * @param ePackage the package in question.
+ * @return whether this is a switch for the given package.
+ * @generated
+ */
+ @Override
+ protected boolean isSwitchFor(EPackage ePackage)
+ {
+ return ePackage == modelPackage;
+ }
+
+ /**
+ * Calls caseXXX
for each class of the model until one returns a non null result; it yields that result.
+ *
+ *
+ * @return the first non-null result returned by a caseXXX
call.
+ * @generated
+ */
+ @Override
+ protected T doSwitch(int classifierID, EObject theEObject)
+ {
+ switch (classifierID)
+ {
+ case IndentationAwareUiTestLanguagePackage.TREE:
+ {
+ Tree tree = (Tree)theEObject;
+ T result = caseTree(tree);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE:
+ {
+ TreeNode treeNode = (TreeNode)theEObject;
+ T result = caseTreeNode(treeNode);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE:
+ {
+ OtherTreeNode otherTreeNode = (OtherTreeNode)theEObject;
+ T result = caseOtherTreeNode(otherTreeNode);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ case IndentationAwareUiTestLanguagePackage.CHILD_LIST:
+ {
+ ChildList childList = (ChildList)theEObject;
+ T result = caseChildList(childList);
+ if (result == null) result = defaultCase(theEObject);
+ return result;
+ }
+ default: return defaultCase(theEObject);
+ }
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Tree'.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Tree'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseTree(Tree object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Tree Node'.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Tree Node'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseTreeNode(TreeNode object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Other Tree Node'.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Other Tree Node'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseOtherTreeNode(OtherTreeNode object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'Child List'.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'Child List'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+ * @generated
+ */
+ public T caseChildList(ChildList object)
+ {
+ return null;
+ }
+
+ /**
+ * Returns the result of interpreting the object as an instance of 'EObject'.
+ *
+ * This implementation returns null;
+ * returning a non-null result will terminate the switch, but this is the last case anyway.
+ *
+ * @param object the target of the switch.
+ * @return the result of interpreting the object as an instance of 'EObject'.
+ * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+ * @generated
+ */
+ @Override
+ public T defaultCase(EObject object)
+ {
+ return null;
+ }
+
+} //IndentationAwareUiTestLanguageSwitch
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/IndentationAwareUiTestLanguageAntlrTokenFileProvider.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/IndentationAwareUiTestLanguageAntlrTokenFileProvider.java
new file mode 100644
index 0000000000..c1bd1686ec
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/IndentationAwareUiTestLanguageAntlrTokenFileProvider.java
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.parser.antlr;
+
+import java.io.InputStream;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+
+public class IndentationAwareUiTestLanguageAntlrTokenFileProvider implements IAntlrTokenFileProvider {
+
+ @Override
+ public InputStream getAntlrTokenFile() {
+ ClassLoader classLoader = getClass().getClassLoader();
+ return classLoader.getResourceAsStream("org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/internal/InternalIndentationAwareUiTestLanguageParser.tokens");
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/IndentationAwareUiTestLanguageParser.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/IndentationAwareUiTestLanguageParser.java
new file mode 100644
index 0000000000..8cc833c597
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/IndentationAwareUiTestLanguageParser.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.parser.antlr;
+
+import com.google.inject.Inject;
+import org.antlr.runtime.CharStream;
+import org.antlr.runtime.TokenSource;
+import org.eclipse.xtext.ide.tests.testlanguage.parser.antlr.internal.InternalIndentationAwareUiTestLanguageParser;
+import org.eclipse.xtext.ide.tests.testlanguage.services.IndentationAwareUiTestLanguageGrammarAccess;
+import org.eclipse.xtext.parser.antlr.AbstractAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+
+public class IndentationAwareUiTestLanguageParser extends AbstractAntlrParser {
+
+ @Inject
+ private IndentationAwareUiTestLanguageGrammarAccess grammarAccess;
+
+ @Override
+ protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
+ tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
+ }
+
+ @Override
+ protected TokenSource createLexer(CharStream stream) {
+ return new IndentationAwareUiTestLanguageTokenSource(super.createLexer(stream));
+ }
+
+ /**
+ * Indentation aware languages do not support partial parsing since the lexer is inherently stateful.
+ * Override and return {@code true} if your terminal splitting is stateless.
+ */
+ @Override
+ protected boolean isReparseSupported() {
+ return false;
+ }
+
+ @Override
+ protected InternalIndentationAwareUiTestLanguageParser createParser(XtextTokenStream stream) {
+ return new InternalIndentationAwareUiTestLanguageParser(stream, getGrammarAccess());
+ }
+
+ @Override
+ protected String getDefaultRuleName() {
+ return "Tree";
+ }
+
+ public IndentationAwareUiTestLanguageGrammarAccess getGrammarAccess() {
+ return this.grammarAccess;
+ }
+
+ public void setGrammarAccess(IndentationAwareUiTestLanguageGrammarAccess grammarAccess) {
+ this.grammarAccess = grammarAccess;
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/internal/InternalIndentationAwareUiTestLanguageParser.g b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/internal/InternalIndentationAwareUiTestLanguageParser.g
new file mode 100644
index 0000000000..29ab926912
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/internal/InternalIndentationAwareUiTestLanguageParser.g
@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+parser grammar InternalIndentationAwareUiTestLanguageParser;
+
+options {
+ tokenVocab=InternalIndentationAwareUiTestLanguageLexer;
+ superClass=AbstractInternalAntlrParser;
+}
+
+@header {
+package org.eclipse.xtext.ide.tests.testlanguage.parser.antlr.internal;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import org.eclipse.xtext.ide.tests.testlanguage.services.IndentationAwareUiTestLanguageGrammarAccess;
+
+}
+
+@members {
+
+ private IndentationAwareUiTestLanguageGrammarAccess grammarAccess;
+
+ public InternalIndentationAwareUiTestLanguageParser(TokenStream input, IndentationAwareUiTestLanguageGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "Tree";
+ }
+
+ @Override
+ protected IndentationAwareUiTestLanguageGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+
+}
+
+@rulecatch {
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+}
+
+// Entry rule entryRuleTree
+entryRuleTree returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getTreeRule()); }
+ iv_ruleTree=ruleTree
+ { $current=$iv_ruleTree.current; }
+ EOF;
+
+// Rule Tree
+ruleTree returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getTreeAccess().getTreeAction_0(),
+ $current);
+ }
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getTreeAccess().getNodesTreeNodeParserRuleCall_1_0());
+ }
+ lv_nodes_1_0=ruleTreeNode
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTreeRule());
+ }
+ add(
+ $current,
+ "nodes",
+ lv_nodes_1_0,
+ "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.TreeNode");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getTreeAccess().getMoreNodesOtherTreeNodeParserRuleCall_2_0());
+ }
+ lv_moreNodes_2_0=ruleOtherTreeNode
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTreeRule());
+ }
+ add(
+ $current,
+ "moreNodes",
+ lv_moreNodes_2_0,
+ "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.OtherTreeNode");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ )
+;
+
+// Entry rule entryRuleTreeNode
+entryRuleTreeNode returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getTreeNodeRule()); }
+ iv_ruleTreeNode=ruleTreeNode
+ { $current=$iv_ruleTreeNode.current; }
+ EOF;
+
+// Rule TreeNode
+ruleTreeNode returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ lv_name_0_0=RULE_ID
+ {
+ newLeafNode(lv_name_0_0, grammarAccess.getTreeNodeAccess().getNameIDTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getTreeNodeRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "name",
+ lv_name_0_0,
+ "org.eclipse.xtext.common.Terminals.ID");
+ }
+ )
+ )
+ (
+ this_INDENT_1=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_1, grammarAccess.getTreeNodeAccess().getINDENTTerminalRuleCall_1_0());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getTreeNodeAccess().getChildrenTreeNodeParserRuleCall_1_1_0());
+ }
+ lv_children_2_0=ruleTreeNode
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getTreeNodeRule());
+ }
+ add(
+ $current,
+ "children",
+ lv_children_2_0,
+ "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.TreeNode");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )*
+ this_DEDENT_3=RULE_DEDENT
+ {
+ newLeafNode(this_DEDENT_3, grammarAccess.getTreeNodeAccess().getDEDENTTerminalRuleCall_1_2());
+ }
+ )?
+ )
+;
+
+// Entry rule entryRuleOtherTreeNode
+entryRuleOtherTreeNode returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getOtherTreeNodeRule()); }
+ iv_ruleOtherTreeNode=ruleOtherTreeNode
+ { $current=$iv_ruleOtherTreeNode.current; }
+ EOF;
+
+// Rule OtherTreeNode
+ruleOtherTreeNode returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ (
+ lv_name_0_0=RULE_STRING
+ {
+ newLeafNode(lv_name_0_0, grammarAccess.getOtherTreeNodeAccess().getNameSTRINGTerminalRuleCall_0_0());
+ }
+ {
+ if ($current==null) {
+ $current = createModelElement(grammarAccess.getOtherTreeNodeRule());
+ }
+ setWithLastConsumed(
+ $current,
+ "name",
+ lv_name_0_0,
+ "org.eclipse.xtext.common.Terminals.STRING");
+ }
+ )
+ )
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getOtherTreeNodeAccess().getChildListChildListParserRuleCall_1_0());
+ }
+ lv_childList_1_0=ruleChildList
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getOtherTreeNodeRule());
+ }
+ set(
+ $current,
+ "childList",
+ lv_childList_1_0,
+ "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.ChildList");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )?
+ )
+;
+
+// Entry rule entryRuleChildList
+entryRuleChildList returns [EObject current=null]:
+ { newCompositeNode(grammarAccess.getChildListRule()); }
+ iv_ruleChildList=ruleChildList
+ { $current=$iv_ruleChildList.current; }
+ EOF;
+
+// Rule ChildList
+ruleChildList returns [EObject current=null]
+@init {
+ enterRule();
+}
+@after {
+ leaveRule();
+}:
+ (
+ (
+ {
+ $current = forceCreateModelElement(
+ grammarAccess.getChildListAccess().getChildListAction_0(),
+ $current);
+ }
+ )
+ this_INDENT_1=RULE_INDENT
+ {
+ newLeafNode(this_INDENT_1, grammarAccess.getChildListAccess().getINDENTTerminalRuleCall_1());
+ }
+ (
+ (
+ {
+ newCompositeNode(grammarAccess.getChildListAccess().getChildrenOtherTreeNodeParserRuleCall_2_0());
+ }
+ lv_children_2_0=ruleOtherTreeNode
+ {
+ if ($current==null) {
+ $current = createModelElementForParent(grammarAccess.getChildListRule());
+ }
+ add(
+ $current,
+ "children",
+ lv_children_2_0,
+ "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.OtherTreeNode");
+ afterParserOrEnumRuleCall();
+ }
+ )
+ )+
+ this_DEDENT_3=RULE_DEDENT
+ {
+ newLeafNode(this_DEDENT_3, grammarAccess.getChildListAccess().getDEDENTTerminalRuleCall_3());
+ }
+ )
+;
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/internal/InternalIndentationAwareUiTestLanguageParser.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/internal/InternalIndentationAwareUiTestLanguageParser.java
new file mode 100644
index 0000000000..05c0a2f6fb
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/internal/InternalIndentationAwareUiTestLanguageParser.java
@@ -0,0 +1,751 @@
+package org.eclipse.xtext.ide.tests.testlanguage.parser.antlr.internal;
+
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import org.eclipse.xtext.ide.tests.testlanguage.services.IndentationAwareUiTestLanguageGrammarAccess;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalIndentationAwareUiTestLanguageParser extends AbstractInternalAntlrParser {
+ public static final String[] tokenNames = new String[] {
+ "", "", "", "", "RULE_SL_COMMENT", "RULE_INDENT", "RULE_DEDENT", "RULE_ID", "RULE_INT", "RULE_STRING", "RULE_ML_COMMENT", "RULE_WS", "RULE_ANY_OTHER"
+ };
+ public static final int RULE_DEDENT=6;
+ public static final int RULE_ID=7;
+ public static final int RULE_WS=11;
+ public static final int RULE_STRING=9;
+ public static final int RULE_ANY_OTHER=12;
+ public static final int RULE_SL_COMMENT=4;
+ public static final int RULE_INT=8;
+ public static final int RULE_ML_COMMENT=10;
+ public static final int EOF=-1;
+ public static final int RULE_INDENT=5;
+
+ // delegates
+ // delegators
+
+
+ public InternalIndentationAwareUiTestLanguageParser(TokenStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalIndentationAwareUiTestLanguageParser(TokenStream input, RecognizerSharedState state) {
+ super(input, state);
+
+ }
+
+
+ public String[] getTokenNames() { return InternalIndentationAwareUiTestLanguageParser.tokenNames; }
+ public String getGrammarFileName() { return "InternalIndentationAwareUiTestLanguageParser.g"; }
+
+
+
+ private IndentationAwareUiTestLanguageGrammarAccess grammarAccess;
+
+ public InternalIndentationAwareUiTestLanguageParser(TokenStream input, IndentationAwareUiTestLanguageGrammarAccess grammarAccess) {
+ this(input);
+ this.grammarAccess = grammarAccess;
+ registerRules(grammarAccess.getGrammar());
+ }
+
+ @Override
+ protected String getFirstRuleName() {
+ return "Tree";
+ }
+
+ @Override
+ protected IndentationAwareUiTestLanguageGrammarAccess getGrammarAccess() {
+ return grammarAccess;
+ }
+
+
+
+
+ // $ANTLR start "entryRuleTree"
+ // InternalIndentationAwareUiTestLanguageParser.g:61:1: entryRuleTree returns [EObject current=null] : iv_ruleTree= ruleTree EOF ;
+ public final EObject entryRuleTree() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleTree = null;
+
+
+ try {
+ // InternalIndentationAwareUiTestLanguageParser.g:61:45: (iv_ruleTree= ruleTree EOF )
+ // InternalIndentationAwareUiTestLanguageParser.g:62:2: iv_ruleTree= ruleTree EOF
+ {
+ newCompositeNode(grammarAccess.getTreeRule());
+ pushFollow(FOLLOW_1);
+ iv_ruleTree=ruleTree();
+
+ state._fsp--;
+
+ current =iv_ruleTree;
+ match(input,EOF,FOLLOW_2);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleTree"
+
+
+ // $ANTLR start "ruleTree"
+ // InternalIndentationAwareUiTestLanguageParser.g:68:1: ruleTree returns [EObject current=null] : ( () ( (lv_nodes_1_0= ruleTreeNode ) )* ( (lv_moreNodes_2_0= ruleOtherTreeNode ) )* ) ;
+ public final EObject ruleTree() throws RecognitionException {
+ EObject current = null;
+
+ EObject lv_nodes_1_0 = null;
+
+ EObject lv_moreNodes_2_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalIndentationAwareUiTestLanguageParser.g:74:2: ( ( () ( (lv_nodes_1_0= ruleTreeNode ) )* ( (lv_moreNodes_2_0= ruleOtherTreeNode ) )* ) )
+ // InternalIndentationAwareUiTestLanguageParser.g:75:2: ( () ( (lv_nodes_1_0= ruleTreeNode ) )* ( (lv_moreNodes_2_0= ruleOtherTreeNode ) )* )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:75:2: ( () ( (lv_nodes_1_0= ruleTreeNode ) )* ( (lv_moreNodes_2_0= ruleOtherTreeNode ) )* )
+ // InternalIndentationAwareUiTestLanguageParser.g:76:3: () ( (lv_nodes_1_0= ruleTreeNode ) )* ( (lv_moreNodes_2_0= ruleOtherTreeNode ) )*
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:76:3: ()
+ // InternalIndentationAwareUiTestLanguageParser.g:77:4:
+ {
+
+ current = forceCreateModelElement(
+ grammarAccess.getTreeAccess().getTreeAction_0(),
+ current);
+
+
+ }
+
+ // InternalIndentationAwareUiTestLanguageParser.g:83:3: ( (lv_nodes_1_0= ruleTreeNode ) )*
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( (LA1_0==RULE_ID) ) {
+ alt1=1;
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageParser.g:84:4: (lv_nodes_1_0= ruleTreeNode )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:84:4: (lv_nodes_1_0= ruleTreeNode )
+ // InternalIndentationAwareUiTestLanguageParser.g:85:5: lv_nodes_1_0= ruleTreeNode
+ {
+
+ newCompositeNode(grammarAccess.getTreeAccess().getNodesTreeNodeParserRuleCall_1_0());
+
+ pushFollow(FOLLOW_3);
+ lv_nodes_1_0=ruleTreeNode();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTreeRule());
+ }
+ add(
+ current,
+ "nodes",
+ lv_nodes_1_0,
+ "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.TreeNode");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop1;
+ }
+ } while (true);
+
+ // InternalIndentationAwareUiTestLanguageParser.g:102:3: ( (lv_moreNodes_2_0= ruleOtherTreeNode ) )*
+ loop2:
+ do {
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( (LA2_0==RULE_STRING) ) {
+ alt2=1;
+ }
+
+
+ switch (alt2) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageParser.g:103:4: (lv_moreNodes_2_0= ruleOtherTreeNode )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:103:4: (lv_moreNodes_2_0= ruleOtherTreeNode )
+ // InternalIndentationAwareUiTestLanguageParser.g:104:5: lv_moreNodes_2_0= ruleOtherTreeNode
+ {
+
+ newCompositeNode(grammarAccess.getTreeAccess().getMoreNodesOtherTreeNodeParserRuleCall_2_0());
+
+ pushFollow(FOLLOW_4);
+ lv_moreNodes_2_0=ruleOtherTreeNode();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTreeRule());
+ }
+ add(
+ current,
+ "moreNodes",
+ lv_moreNodes_2_0,
+ "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.OtherTreeNode");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop2;
+ }
+ } while (true);
+
+
+ }
+
+
+ }
+
+
+ leaveRule();
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleTree"
+
+
+ // $ANTLR start "entryRuleTreeNode"
+ // InternalIndentationAwareUiTestLanguageParser.g:125:1: entryRuleTreeNode returns [EObject current=null] : iv_ruleTreeNode= ruleTreeNode EOF ;
+ public final EObject entryRuleTreeNode() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleTreeNode = null;
+
+
+ try {
+ // InternalIndentationAwareUiTestLanguageParser.g:125:49: (iv_ruleTreeNode= ruleTreeNode EOF )
+ // InternalIndentationAwareUiTestLanguageParser.g:126:2: iv_ruleTreeNode= ruleTreeNode EOF
+ {
+ newCompositeNode(grammarAccess.getTreeNodeRule());
+ pushFollow(FOLLOW_1);
+ iv_ruleTreeNode=ruleTreeNode();
+
+ state._fsp--;
+
+ current =iv_ruleTreeNode;
+ match(input,EOF,FOLLOW_2);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleTreeNode"
+
+
+ // $ANTLR start "ruleTreeNode"
+ // InternalIndentationAwareUiTestLanguageParser.g:132:1: ruleTreeNode returns [EObject current=null] : ( ( (lv_name_0_0= RULE_ID ) ) (this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleTreeNode ) )* this_DEDENT_3= RULE_DEDENT )? ) ;
+ public final EObject ruleTreeNode() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_name_0_0=null;
+ Token this_INDENT_1=null;
+ Token this_DEDENT_3=null;
+ EObject lv_children_2_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalIndentationAwareUiTestLanguageParser.g:138:2: ( ( ( (lv_name_0_0= RULE_ID ) ) (this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleTreeNode ) )* this_DEDENT_3= RULE_DEDENT )? ) )
+ // InternalIndentationAwareUiTestLanguageParser.g:139:2: ( ( (lv_name_0_0= RULE_ID ) ) (this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleTreeNode ) )* this_DEDENT_3= RULE_DEDENT )? )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:139:2: ( ( (lv_name_0_0= RULE_ID ) ) (this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleTreeNode ) )* this_DEDENT_3= RULE_DEDENT )? )
+ // InternalIndentationAwareUiTestLanguageParser.g:140:3: ( (lv_name_0_0= RULE_ID ) ) (this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleTreeNode ) )* this_DEDENT_3= RULE_DEDENT )?
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:140:3: ( (lv_name_0_0= RULE_ID ) )
+ // InternalIndentationAwareUiTestLanguageParser.g:141:4: (lv_name_0_0= RULE_ID )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:141:4: (lv_name_0_0= RULE_ID )
+ // InternalIndentationAwareUiTestLanguageParser.g:142:5: lv_name_0_0= RULE_ID
+ {
+ lv_name_0_0=(Token)match(input,RULE_ID,FOLLOW_5);
+
+ newLeafNode(lv_name_0_0, grammarAccess.getTreeNodeAccess().getNameIDTerminalRuleCall_0_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getTreeNodeRule());
+ }
+ setWithLastConsumed(
+ current,
+ "name",
+ lv_name_0_0,
+ "org.eclipse.xtext.common.Terminals.ID");
+
+
+ }
+
+
+ }
+
+ // InternalIndentationAwareUiTestLanguageParser.g:158:3: (this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleTreeNode ) )* this_DEDENT_3= RULE_DEDENT )?
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( (LA4_0==RULE_INDENT) ) {
+ alt4=1;
+ }
+ switch (alt4) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageParser.g:159:4: this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleTreeNode ) )* this_DEDENT_3= RULE_DEDENT
+ {
+ this_INDENT_1=(Token)match(input,RULE_INDENT,FOLLOW_6);
+
+ newLeafNode(this_INDENT_1, grammarAccess.getTreeNodeAccess().getINDENTTerminalRuleCall_1_0());
+
+ // InternalIndentationAwareUiTestLanguageParser.g:163:4: ( (lv_children_2_0= ruleTreeNode ) )*
+ loop3:
+ do {
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( (LA3_0==RULE_ID) ) {
+ alt3=1;
+ }
+
+
+ switch (alt3) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageParser.g:164:5: (lv_children_2_0= ruleTreeNode )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:164:5: (lv_children_2_0= ruleTreeNode )
+ // InternalIndentationAwareUiTestLanguageParser.g:165:6: lv_children_2_0= ruleTreeNode
+ {
+
+ newCompositeNode(grammarAccess.getTreeNodeAccess().getChildrenTreeNodeParserRuleCall_1_1_0());
+
+ pushFollow(FOLLOW_6);
+ lv_children_2_0=ruleTreeNode();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getTreeNodeRule());
+ }
+ add(
+ current,
+ "children",
+ lv_children_2_0,
+ "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.TreeNode");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ break loop3;
+ }
+ } while (true);
+
+ this_DEDENT_3=(Token)match(input,RULE_DEDENT,FOLLOW_2);
+
+ newLeafNode(this_DEDENT_3, grammarAccess.getTreeNodeAccess().getDEDENTTerminalRuleCall_1_2());
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ leaveRule();
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleTreeNode"
+
+
+ // $ANTLR start "entryRuleOtherTreeNode"
+ // InternalIndentationAwareUiTestLanguageParser.g:191:1: entryRuleOtherTreeNode returns [EObject current=null] : iv_ruleOtherTreeNode= ruleOtherTreeNode EOF ;
+ public final EObject entryRuleOtherTreeNode() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleOtherTreeNode = null;
+
+
+ try {
+ // InternalIndentationAwareUiTestLanguageParser.g:191:54: (iv_ruleOtherTreeNode= ruleOtherTreeNode EOF )
+ // InternalIndentationAwareUiTestLanguageParser.g:192:2: iv_ruleOtherTreeNode= ruleOtherTreeNode EOF
+ {
+ newCompositeNode(grammarAccess.getOtherTreeNodeRule());
+ pushFollow(FOLLOW_1);
+ iv_ruleOtherTreeNode=ruleOtherTreeNode();
+
+ state._fsp--;
+
+ current =iv_ruleOtherTreeNode;
+ match(input,EOF,FOLLOW_2);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleOtherTreeNode"
+
+
+ // $ANTLR start "ruleOtherTreeNode"
+ // InternalIndentationAwareUiTestLanguageParser.g:198:1: ruleOtherTreeNode returns [EObject current=null] : ( ( (lv_name_0_0= RULE_STRING ) ) ( (lv_childList_1_0= ruleChildList ) )? ) ;
+ public final EObject ruleOtherTreeNode() throws RecognitionException {
+ EObject current = null;
+
+ Token lv_name_0_0=null;
+ EObject lv_childList_1_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalIndentationAwareUiTestLanguageParser.g:204:2: ( ( ( (lv_name_0_0= RULE_STRING ) ) ( (lv_childList_1_0= ruleChildList ) )? ) )
+ // InternalIndentationAwareUiTestLanguageParser.g:205:2: ( ( (lv_name_0_0= RULE_STRING ) ) ( (lv_childList_1_0= ruleChildList ) )? )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:205:2: ( ( (lv_name_0_0= RULE_STRING ) ) ( (lv_childList_1_0= ruleChildList ) )? )
+ // InternalIndentationAwareUiTestLanguageParser.g:206:3: ( (lv_name_0_0= RULE_STRING ) ) ( (lv_childList_1_0= ruleChildList ) )?
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:206:3: ( (lv_name_0_0= RULE_STRING ) )
+ // InternalIndentationAwareUiTestLanguageParser.g:207:4: (lv_name_0_0= RULE_STRING )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:207:4: (lv_name_0_0= RULE_STRING )
+ // InternalIndentationAwareUiTestLanguageParser.g:208:5: lv_name_0_0= RULE_STRING
+ {
+ lv_name_0_0=(Token)match(input,RULE_STRING,FOLLOW_5);
+
+ newLeafNode(lv_name_0_0, grammarAccess.getOtherTreeNodeAccess().getNameSTRINGTerminalRuleCall_0_0());
+
+
+ if (current==null) {
+ current = createModelElement(grammarAccess.getOtherTreeNodeRule());
+ }
+ setWithLastConsumed(
+ current,
+ "name",
+ lv_name_0_0,
+ "org.eclipse.xtext.common.Terminals.STRING");
+
+
+ }
+
+
+ }
+
+ // InternalIndentationAwareUiTestLanguageParser.g:224:3: ( (lv_childList_1_0= ruleChildList ) )?
+ int alt5=2;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0==RULE_INDENT) ) {
+ alt5=1;
+ }
+ switch (alt5) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageParser.g:225:4: (lv_childList_1_0= ruleChildList )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:225:4: (lv_childList_1_0= ruleChildList )
+ // InternalIndentationAwareUiTestLanguageParser.g:226:5: lv_childList_1_0= ruleChildList
+ {
+
+ newCompositeNode(grammarAccess.getOtherTreeNodeAccess().getChildListChildListParserRuleCall_1_0());
+
+ pushFollow(FOLLOW_2);
+ lv_childList_1_0=ruleChildList();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getOtherTreeNodeRule());
+ }
+ set(
+ current,
+ "childList",
+ lv_childList_1_0,
+ "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.ChildList");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ }
+
+
+ }
+
+
+ }
+
+
+ leaveRule();
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleOtherTreeNode"
+
+
+ // $ANTLR start "entryRuleChildList"
+ // InternalIndentationAwareUiTestLanguageParser.g:247:1: entryRuleChildList returns [EObject current=null] : iv_ruleChildList= ruleChildList EOF ;
+ public final EObject entryRuleChildList() throws RecognitionException {
+ EObject current = null;
+
+ EObject iv_ruleChildList = null;
+
+
+ try {
+ // InternalIndentationAwareUiTestLanguageParser.g:247:50: (iv_ruleChildList= ruleChildList EOF )
+ // InternalIndentationAwareUiTestLanguageParser.g:248:2: iv_ruleChildList= ruleChildList EOF
+ {
+ newCompositeNode(grammarAccess.getChildListRule());
+ pushFollow(FOLLOW_1);
+ iv_ruleChildList=ruleChildList();
+
+ state._fsp--;
+
+ current =iv_ruleChildList;
+ match(input,EOF,FOLLOW_2);
+
+ }
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "entryRuleChildList"
+
+
+ // $ANTLR start "ruleChildList"
+ // InternalIndentationAwareUiTestLanguageParser.g:254:1: ruleChildList returns [EObject current=null] : ( () this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleOtherTreeNode ) )+ this_DEDENT_3= RULE_DEDENT ) ;
+ public final EObject ruleChildList() throws RecognitionException {
+ EObject current = null;
+
+ Token this_INDENT_1=null;
+ Token this_DEDENT_3=null;
+ EObject lv_children_2_0 = null;
+
+
+
+ enterRule();
+
+ try {
+ // InternalIndentationAwareUiTestLanguageParser.g:260:2: ( ( () this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleOtherTreeNode ) )+ this_DEDENT_3= RULE_DEDENT ) )
+ // InternalIndentationAwareUiTestLanguageParser.g:261:2: ( () this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleOtherTreeNode ) )+ this_DEDENT_3= RULE_DEDENT )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:261:2: ( () this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleOtherTreeNode ) )+ this_DEDENT_3= RULE_DEDENT )
+ // InternalIndentationAwareUiTestLanguageParser.g:262:3: () this_INDENT_1= RULE_INDENT ( (lv_children_2_0= ruleOtherTreeNode ) )+ this_DEDENT_3= RULE_DEDENT
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:262:3: ()
+ // InternalIndentationAwareUiTestLanguageParser.g:263:4:
+ {
+
+ current = forceCreateModelElement(
+ grammarAccess.getChildListAccess().getChildListAction_0(),
+ current);
+
+
+ }
+
+ this_INDENT_1=(Token)match(input,RULE_INDENT,FOLLOW_7);
+
+ newLeafNode(this_INDENT_1, grammarAccess.getChildListAccess().getINDENTTerminalRuleCall_1());
+
+ // InternalIndentationAwareUiTestLanguageParser.g:273:3: ( (lv_children_2_0= ruleOtherTreeNode ) )+
+ int cnt6=0;
+ loop6:
+ do {
+ int alt6=2;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0==RULE_STRING) ) {
+ alt6=1;
+ }
+
+
+ switch (alt6) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageParser.g:274:4: (lv_children_2_0= ruleOtherTreeNode )
+ {
+ // InternalIndentationAwareUiTestLanguageParser.g:274:4: (lv_children_2_0= ruleOtherTreeNode )
+ // InternalIndentationAwareUiTestLanguageParser.g:275:5: lv_children_2_0= ruleOtherTreeNode
+ {
+
+ newCompositeNode(grammarAccess.getChildListAccess().getChildrenOtherTreeNodeParserRuleCall_2_0());
+
+ pushFollow(FOLLOW_8);
+ lv_children_2_0=ruleOtherTreeNode();
+
+ state._fsp--;
+
+
+ if (current==null) {
+ current = createModelElementForParent(grammarAccess.getChildListRule());
+ }
+ add(
+ current,
+ "children",
+ lv_children_2_0,
+ "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.OtherTreeNode");
+ afterParserOrEnumRuleCall();
+
+
+ }
+
+
+ }
+ break;
+
+ default :
+ if ( cnt6 >= 1 ) break loop6;
+ EarlyExitException eee =
+ new EarlyExitException(6, input);
+ throw eee;
+ }
+ cnt6++;
+ } while (true);
+
+ this_DEDENT_3=(Token)match(input,RULE_DEDENT,FOLLOW_2);
+
+ newLeafNode(this_DEDENT_3, grammarAccess.getChildListAccess().getDEDENTTerminalRuleCall_3());
+
+
+ }
+
+
+ }
+
+
+ leaveRule();
+
+ }
+
+ catch (RecognitionException re) {
+ recover(input,re);
+ appendSkippedTokens();
+ }
+ finally {
+ }
+ return current;
+ }
+ // $ANTLR end "ruleChildList"
+
+ // Delegated rules
+
+
+
+
+ public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
+ public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
+ public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000282L});
+ public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000202L});
+ public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000022L});
+ public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x00000000000002C0L});
+ public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000200L});
+ public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000240L});
+
+}
\ No newline at end of file
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/internal/InternalIndentationAwareUiTestLanguageParser.tokens b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/internal/InternalIndentationAwareUiTestLanguageParser.tokens
new file mode 100644
index 0000000000..eae27a90fe
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/internal/InternalIndentationAwareUiTestLanguageParser.tokens
@@ -0,0 +1,9 @@
+RULE_ANY_OTHER=12
+RULE_DEDENT=6
+RULE_ID=7
+RULE_INDENT=5
+RULE_INT=8
+RULE_ML_COMMENT=10
+RULE_SL_COMMENT=4
+RULE_STRING=9
+RULE_WS=11
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/lexer/InternalIndentationAwareUiTestLanguageLexer.g b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/lexer/InternalIndentationAwareUiTestLanguageLexer.g
new file mode 100644
index 0000000000..cb81a1829c
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/lexer/InternalIndentationAwareUiTestLanguageLexer.g
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+lexer grammar InternalIndentationAwareUiTestLanguageLexer;
+
+@header {
+package org.eclipse.xtext.ide.tests.testlanguage.parser.antlr.lexer;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.parser.antlr.Lexer;
+}
+
+RULE_SL_COMMENT : '//' ~(('\n'|'\r'))*;
+
+fragment RULE_INDENT : ;
+
+fragment RULE_DEDENT : ;
+
+RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;
+
+RULE_INT : ('0'..'9')+;
+
+RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\'');
+
+RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
+
+RULE_WS : (' '|'\t'|'\r'|'\n')+;
+
+RULE_ANY_OTHER : .;
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/lexer/InternalIndentationAwareUiTestLanguageLexer.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/lexer/InternalIndentationAwareUiTestLanguageLexer.java
new file mode 100644
index 0000000000..3599b1141e
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/lexer/InternalIndentationAwareUiTestLanguageLexer.java
@@ -0,0 +1,707 @@
+package org.eclipse.xtext.ide.tests.testlanguage.parser.antlr.lexer;
+
+// Hack: Use our own Lexer superclass by means of import.
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.parser.antlr.Lexer;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalIndentationAwareUiTestLanguageLexer extends Lexer {
+ public static final int RULE_DEDENT=6;
+ public static final int RULE_ID=7;
+ public static final int RULE_WS=11;
+ public static final int RULE_STRING=9;
+ public static final int RULE_ANY_OTHER=12;
+ public static final int RULE_SL_COMMENT=4;
+ public static final int RULE_INT=8;
+ public static final int RULE_ML_COMMENT=10;
+ public static final int EOF=-1;
+ public static final int RULE_INDENT=5;
+
+ // delegates
+ // delegators
+
+ public InternalIndentationAwareUiTestLanguageLexer() {;}
+ public InternalIndentationAwareUiTestLanguageLexer(CharStream input) {
+ this(input, new RecognizerSharedState());
+ }
+ public InternalIndentationAwareUiTestLanguageLexer(CharStream input, RecognizerSharedState state) {
+ super(input,state);
+
+ }
+ public String getGrammarFileName() { return "InternalIndentationAwareUiTestLanguageLexer.g"; }
+
+ // $ANTLR start "RULE_SL_COMMENT"
+ public final void mRULE_SL_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_SL_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalIndentationAwareUiTestLanguageLexer.g:18:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* )
+ // InternalIndentationAwareUiTestLanguageLexer.g:18:19: '//' (~ ( ( '\\n' | '\\r' ) ) )*
+ {
+ match("//");
+
+ // InternalIndentationAwareUiTestLanguageLexer.g:18:24: (~ ( ( '\\n' | '\\r' ) ) )*
+ loop1:
+ do {
+ int alt1=2;
+ int LA1_0 = input.LA(1);
+
+ if ( ((LA1_0>='\u0000' && LA1_0<='\t')||(LA1_0>='\u000B' && LA1_0<='\f')||(LA1_0>='\u000E' && LA1_0<='\uFFFF')) ) {
+ alt1=1;
+ }
+
+
+ switch (alt1) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:18:24: ~ ( ( '\\n' | '\\r' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='\t')||(input.LA(1)>='\u000B' && input.LA(1)<='\f')||(input.LA(1)>='\u000E' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop1;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_SL_COMMENT"
+
+ // $ANTLR start "RULE_INDENT"
+ public final void mRULE_INDENT() throws RecognitionException {
+ try {
+ // InternalIndentationAwareUiTestLanguageLexer.g:20:22: ()
+ // InternalIndentationAwareUiTestLanguageLexer.g:20:24:
+ {
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INDENT"
+
+ // $ANTLR start "RULE_DEDENT"
+ public final void mRULE_DEDENT() throws RecognitionException {
+ try {
+ // InternalIndentationAwareUiTestLanguageLexer.g:22:22: ()
+ // InternalIndentationAwareUiTestLanguageLexer.g:22:24:
+ {
+ }
+
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_DEDENT"
+
+ // $ANTLR start "RULE_ID"
+ public final void mRULE_ID() throws RecognitionException {
+ try {
+ int _type = RULE_ID;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalIndentationAwareUiTestLanguageLexer.g:24:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )* )
+ // InternalIndentationAwareUiTestLanguageLexer.g:24:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ {
+ // InternalIndentationAwareUiTestLanguageLexer.g:24:11: ( '^' )?
+ int alt2=2;
+ int LA2_0 = input.LA(1);
+
+ if ( (LA2_0=='^') ) {
+ alt2=1;
+ }
+ switch (alt2) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:24:11: '^'
+ {
+ match('^');
+
+ }
+ break;
+
+ }
+
+ if ( (input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+ // InternalIndentationAwareUiTestLanguageLexer.g:24:40: ( 'a' .. 'z' | 'A' .. 'Z' | '_' | '0' .. '9' )*
+ loop3:
+ do {
+ int alt3=2;
+ int LA3_0 = input.LA(1);
+
+ if ( ((LA3_0>='0' && LA3_0<='9')||(LA3_0>='A' && LA3_0<='Z')||LA3_0=='_'||(LA3_0>='a' && LA3_0<='z')) ) {
+ alt3=1;
+ }
+
+
+ switch (alt3) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:
+ {
+ if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='Z')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='z') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop3;
+ }
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ID"
+
+ // $ANTLR start "RULE_INT"
+ public final void mRULE_INT() throws RecognitionException {
+ try {
+ int _type = RULE_INT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalIndentationAwareUiTestLanguageLexer.g:26:10: ( ( '0' .. '9' )+ )
+ // InternalIndentationAwareUiTestLanguageLexer.g:26:12: ( '0' .. '9' )+
+ {
+ // InternalIndentationAwareUiTestLanguageLexer.g:26:12: ( '0' .. '9' )+
+ int cnt4=0;
+ loop4:
+ do {
+ int alt4=2;
+ int LA4_0 = input.LA(1);
+
+ if ( ((LA4_0>='0' && LA4_0<='9')) ) {
+ alt4=1;
+ }
+
+
+ switch (alt4) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:26:13: '0' .. '9'
+ {
+ matchRange('0','9');
+
+ }
+ break;
+
+ default :
+ if ( cnt4 >= 1 ) break loop4;
+ EarlyExitException eee =
+ new EarlyExitException(4, input);
+ throw eee;
+ }
+ cnt4++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_INT"
+
+ // $ANTLR start "RULE_STRING"
+ public final void mRULE_STRING() throws RecognitionException {
+ try {
+ int _type = RULE_STRING;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' ) )
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+ {
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"' | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\'' )
+ int alt7=2;
+ int LA7_0 = input.LA(1);
+
+ if ( (LA7_0=='\"') ) {
+ alt7=1;
+ }
+ else if ( (LA7_0=='\'') ) {
+ alt7=2;
+ }
+ else {
+ NoViableAltException nvae =
+ new NoViableAltException("", 7, 0, input);
+
+ throw nvae;
+ }
+ switch (alt7) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* '\"'
+ {
+ match('\"');
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+ loop5:
+ do {
+ int alt5=3;
+ int LA5_0 = input.LA(1);
+
+ if ( (LA5_0=='\\') ) {
+ alt5=1;
+ }
+ else if ( ((LA5_0>='\u0000' && LA5_0<='!')||(LA5_0>='#' && LA5_0<='[')||(LA5_0>=']' && LA5_0<='\uFFFF')) ) {
+ alt5=2;
+ }
+
+
+ switch (alt5) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:21: '\\\\' .
+ {
+ match('\\');
+ matchAny();
+
+ }
+ break;
+ case 2 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:28: ~ ( ( '\\\\' | '\"' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='!')||(input.LA(1)>='#' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop5;
+ }
+ } while (true);
+
+ match('\"');
+
+ }
+ break;
+ case 2 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:48: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* '\\''
+ {
+ match('\'');
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:53: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+ loop6:
+ do {
+ int alt6=3;
+ int LA6_0 = input.LA(1);
+
+ if ( (LA6_0=='\\') ) {
+ alt6=1;
+ }
+ else if ( ((LA6_0>='\u0000' && LA6_0<='&')||(LA6_0>='(' && LA6_0<='[')||(LA6_0>=']' && LA6_0<='\uFFFF')) ) {
+ alt6=2;
+ }
+
+
+ switch (alt6) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:54: '\\\\' .
+ {
+ match('\\');
+ matchAny();
+
+ }
+ break;
+ case 2 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:28:61: ~ ( ( '\\\\' | '\\'' ) )
+ {
+ if ( (input.LA(1)>='\u0000' && input.LA(1)<='&')||(input.LA(1)>='(' && input.LA(1)<='[')||(input.LA(1)>=']' && input.LA(1)<='\uFFFF') ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ break loop6;
+ }
+ } while (true);
+
+ match('\'');
+
+ }
+ break;
+
+ }
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_STRING"
+
+ // $ANTLR start "RULE_ML_COMMENT"
+ public final void mRULE_ML_COMMENT() throws RecognitionException {
+ try {
+ int _type = RULE_ML_COMMENT;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalIndentationAwareUiTestLanguageLexer.g:30:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+ // InternalIndentationAwareUiTestLanguageLexer.g:30:19: '/*' ( options {greedy=false; } : . )* '*/'
+ {
+ match("/*");
+
+ // InternalIndentationAwareUiTestLanguageLexer.g:30:24: ( options {greedy=false; } : . )*
+ loop8:
+ do {
+ int alt8=2;
+ int LA8_0 = input.LA(1);
+
+ if ( (LA8_0=='*') ) {
+ int LA8_1 = input.LA(2);
+
+ if ( (LA8_1=='/') ) {
+ alt8=2;
+ }
+ else if ( ((LA8_1>='\u0000' && LA8_1<='.')||(LA8_1>='0' && LA8_1<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ }
+ else if ( ((LA8_0>='\u0000' && LA8_0<=')')||(LA8_0>='+' && LA8_0<='\uFFFF')) ) {
+ alt8=1;
+ }
+
+
+ switch (alt8) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:30:52: .
+ {
+ matchAny();
+
+ }
+ break;
+
+ default :
+ break loop8;
+ }
+ } while (true);
+
+ match("*/");
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ML_COMMENT"
+
+ // $ANTLR start "RULE_WS"
+ public final void mRULE_WS() throws RecognitionException {
+ try {
+ int _type = RULE_WS;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalIndentationAwareUiTestLanguageLexer.g:32:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+ // InternalIndentationAwareUiTestLanguageLexer.g:32:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+ {
+ // InternalIndentationAwareUiTestLanguageLexer.g:32:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+ int cnt9=0;
+ loop9:
+ do {
+ int alt9=2;
+ int LA9_0 = input.LA(1);
+
+ if ( ((LA9_0>='\t' && LA9_0<='\n')||LA9_0=='\r'||LA9_0==' ') ) {
+ alt9=1;
+ }
+
+
+ switch (alt9) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:
+ {
+ if ( (input.LA(1)>='\t' && input.LA(1)<='\n')||input.LA(1)=='\r'||input.LA(1)==' ' ) {
+ input.consume();
+
+ }
+ else {
+ MismatchedSetException mse = new MismatchedSetException(null,input);
+ recover(mse);
+ throw mse;}
+
+
+ }
+ break;
+
+ default :
+ if ( cnt9 >= 1 ) break loop9;
+ EarlyExitException eee =
+ new EarlyExitException(9, input);
+ throw eee;
+ }
+ cnt9++;
+ } while (true);
+
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_WS"
+
+ // $ANTLR start "RULE_ANY_OTHER"
+ public final void mRULE_ANY_OTHER() throws RecognitionException {
+ try {
+ int _type = RULE_ANY_OTHER;
+ int _channel = DEFAULT_TOKEN_CHANNEL;
+ // InternalIndentationAwareUiTestLanguageLexer.g:34:16: ( . )
+ // InternalIndentationAwareUiTestLanguageLexer.g:34:18: .
+ {
+ matchAny();
+
+ }
+
+ state.type = _type;
+ state.channel = _channel;
+ }
+ finally {
+ }
+ }
+ // $ANTLR end "RULE_ANY_OTHER"
+
+ public void mTokens() throws RecognitionException {
+ // InternalIndentationAwareUiTestLanguageLexer.g:1:8: ( RULE_SL_COMMENT | RULE_ID | RULE_INT | RULE_STRING | RULE_ML_COMMENT | RULE_WS | RULE_ANY_OTHER )
+ int alt10=7;
+ alt10 = dfa10.predict(input);
+ switch (alt10) {
+ case 1 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:1:10: RULE_SL_COMMENT
+ {
+ mRULE_SL_COMMENT();
+
+ }
+ break;
+ case 2 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:1:26: RULE_ID
+ {
+ mRULE_ID();
+
+ }
+ break;
+ case 3 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:1:34: RULE_INT
+ {
+ mRULE_INT();
+
+ }
+ break;
+ case 4 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:1:43: RULE_STRING
+ {
+ mRULE_STRING();
+
+ }
+ break;
+ case 5 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:1:55: RULE_ML_COMMENT
+ {
+ mRULE_ML_COMMENT();
+
+ }
+ break;
+ case 6 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:1:71: RULE_WS
+ {
+ mRULE_WS();
+
+ }
+ break;
+ case 7 :
+ // InternalIndentationAwareUiTestLanguageLexer.g:1:79: RULE_ANY_OTHER
+ {
+ mRULE_ANY_OTHER();
+
+ }
+ break;
+
+ }
+
+ }
+
+
+ protected DFA10 dfa10 = new DFA10(this);
+ static final String DFA10_eotS =
+ "\1\uffff\2\10\2\uffff\2\10\10\uffff";
+ static final String DFA10_eofS =
+ "\17\uffff";
+ static final String DFA10_minS =
+ "\1\0\1\52\1\101\2\uffff\2\0\10\uffff";
+ static final String DFA10_maxS =
+ "\1\uffff\1\57\1\172\2\uffff\2\uffff\10\uffff";
+ static final String DFA10_acceptS =
+ "\3\uffff\1\2\1\3\2\uffff\1\6\1\7\1\1\1\5\1\2\1\3\1\4\1\6";
+ static final String DFA10_specialS =
+ "\1\2\4\uffff\1\0\1\1\10\uffff}>";
+ static final String[] DFA10_transitionS = {
+ "\11\10\2\7\2\10\1\7\22\10\1\7\1\10\1\5\4\10\1\6\7\10\1\1\12\4\7\10\32\3\3\10\1\2\1\3\1\10\32\3\uff85\10",
+ "\1\12\4\uffff\1\11",
+ "\32\13\4\uffff\1\13\1\uffff\32\13",
+ "",
+ "",
+ "\0\15",
+ "\0\15",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ "",
+ ""
+ };
+
+ static final short[] DFA10_eot = DFA.unpackEncodedString(DFA10_eotS);
+ static final short[] DFA10_eof = DFA.unpackEncodedString(DFA10_eofS);
+ static final char[] DFA10_min = DFA.unpackEncodedStringToUnsignedChars(DFA10_minS);
+ static final char[] DFA10_max = DFA.unpackEncodedStringToUnsignedChars(DFA10_maxS);
+ static final short[] DFA10_accept = DFA.unpackEncodedString(DFA10_acceptS);
+ static final short[] DFA10_special = DFA.unpackEncodedString(DFA10_specialS);
+ static final short[][] DFA10_transition;
+
+ static {
+ int numStates = DFA10_transitionS.length;
+ DFA10_transition = new short[numStates][];
+ for (int i=0; i='\u0000' && LA10_5<='\uFFFF')) ) {s = 13;}
+
+ else s = 8;
+
+ if ( s>=0 ) return s;
+ break;
+ case 1 :
+ int LA10_6 = input.LA(1);
+
+ s = -1;
+ if ( ((LA10_6>='\u0000' && LA10_6<='\uFFFF')) ) {s = 13;}
+
+ else s = 8;
+
+ if ( s>=0 ) return s;
+ break;
+ case 2 :
+ int LA10_0 = input.LA(1);
+
+ s = -1;
+ if ( (LA10_0=='/') ) {s = 1;}
+
+ else if ( (LA10_0=='^') ) {s = 2;}
+
+ else if ( ((LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='a' && LA10_0<='z')) ) {s = 3;}
+
+ else if ( ((LA10_0>='0' && LA10_0<='9')) ) {s = 4;}
+
+ else if ( (LA10_0=='\"') ) {s = 5;}
+
+ else if ( (LA10_0=='\'') ) {s = 6;}
+
+ else if ( ((LA10_0>='\t' && LA10_0<='\n')||LA10_0=='\r'||LA10_0==' ') ) {s = 7;}
+
+ else if ( ((LA10_0>='\u0000' && LA10_0<='\b')||(LA10_0>='\u000B' && LA10_0<='\f')||(LA10_0>='\u000E' && LA10_0<='\u001F')||LA10_0=='!'||(LA10_0>='#' && LA10_0<='&')||(LA10_0>='(' && LA10_0<='.')||(LA10_0>=':' && LA10_0<='@')||(LA10_0>='[' && LA10_0<=']')||LA10_0=='`'||(LA10_0>='{' && LA10_0<='\uFFFF')) ) {s = 8;}
+
+ if ( s>=0 ) return s;
+ break;
+ }
+ NoViableAltException nvae =
+ new NoViableAltException(getDescription(), 10, _s, input);
+ error(nvae);
+ throw nvae;
+ }
+ }
+
+
+}
\ No newline at end of file
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/lexer/InternalIndentationAwareUiTestLanguageLexer.tokens b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/lexer/InternalIndentationAwareUiTestLanguageLexer.tokens
new file mode 100644
index 0000000000..eae27a90fe
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/lexer/InternalIndentationAwareUiTestLanguageLexer.tokens
@@ -0,0 +1,9 @@
+RULE_ANY_OTHER=12
+RULE_DEDENT=6
+RULE_ID=7
+RULE_INDENT=5
+RULE_INT=8
+RULE_ML_COMMENT=10
+RULE_SL_COMMENT=4
+RULE_STRING=9
+RULE_WS=11
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/scoping/AbstractIndentationAwareUiTestLanguageScopeProvider.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/scoping/AbstractIndentationAwareUiTestLanguageScopeProvider.java
new file mode 100644
index 0000000000..88c56b8737
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/scoping/AbstractIndentationAwareUiTestLanguageScopeProvider.java
@@ -0,0 +1,13 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.scoping;
+
+import org.eclipse.xtext.scoping.impl.DelegatingScopeProvider;
+
+public abstract class AbstractIndentationAwareUiTestLanguageScopeProvider extends DelegatingScopeProvider {
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/serializer/IndentationAwareUiTestLanguageSemanticSequencer.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/serializer/IndentationAwareUiTestLanguageSemanticSequencer.java
new file mode 100644
index 0000000000..31cac8d91b
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/serializer/IndentationAwareUiTestLanguageSemanticSequencer.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.serializer;
+
+import com.google.inject.Inject;
+import java.util.Set;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.xtext.Action;
+import org.eclipse.xtext.Parameter;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.ChildList;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.IndentationAwareUiTestLanguagePackage;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.OtherTreeNode;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.Tree;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.TreeNode;
+import org.eclipse.xtext.ide.tests.testlanguage.services.IndentationAwareUiTestLanguageGrammarAccess;
+import org.eclipse.xtext.serializer.ISerializationContext;
+import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
+
+@SuppressWarnings("all")
+public class IndentationAwareUiTestLanguageSemanticSequencer extends AbstractDelegatingSemanticSequencer {
+
+ @Inject
+ private IndentationAwareUiTestLanguageGrammarAccess grammarAccess;
+
+ @Override
+ public void sequence(ISerializationContext context, EObject semanticObject) {
+ EPackage epackage = semanticObject.eClass().getEPackage();
+ ParserRule rule = context.getParserRule();
+ Action action = context.getAssignedAction();
+ Set parameters = context.getEnabledBooleanParameters();
+ if (epackage == IndentationAwareUiTestLanguagePackage.eINSTANCE)
+ switch (semanticObject.eClass().getClassifierID()) {
+ case IndentationAwareUiTestLanguagePackage.CHILD_LIST:
+ sequence_ChildList(context, (ChildList) semanticObject);
+ return;
+ case IndentationAwareUiTestLanguagePackage.OTHER_TREE_NODE:
+ sequence_OtherTreeNode(context, (OtherTreeNode) semanticObject);
+ return;
+ case IndentationAwareUiTestLanguagePackage.TREE:
+ sequence_Tree(context, (Tree) semanticObject);
+ return;
+ case IndentationAwareUiTestLanguagePackage.TREE_NODE:
+ sequence_TreeNode(context, (TreeNode) semanticObject);
+ return;
+ }
+ if (errorAcceptor != null)
+ errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
+ }
+
+ /**
+ * Contexts:
+ * ChildList returns ChildList
+ *
+ * Constraint:
+ * children+=OtherTreeNode+
+ */
+ protected void sequence_ChildList(ISerializationContext context, ChildList semanticObject) {
+ genericSequencer.createSequence(context, semanticObject);
+ }
+
+
+ /**
+ * Contexts:
+ * OtherTreeNode returns OtherTreeNode
+ *
+ * Constraint:
+ * (name=STRING childList=ChildList?)
+ */
+ protected void sequence_OtherTreeNode(ISerializationContext context, OtherTreeNode semanticObject) {
+ genericSequencer.createSequence(context, semanticObject);
+ }
+
+
+ /**
+ * Contexts:
+ * TreeNode returns TreeNode
+ *
+ * Constraint:
+ * (name=ID children+=TreeNode*)
+ */
+ protected void sequence_TreeNode(ISerializationContext context, TreeNode semanticObject) {
+ genericSequencer.createSequence(context, semanticObject);
+ }
+
+
+ /**
+ * Contexts:
+ * Tree returns Tree
+ *
+ * Constraint:
+ * (nodes+=TreeNode* moreNodes+=OtherTreeNode*)
+ */
+ protected void sequence_Tree(ISerializationContext context, Tree semanticObject) {
+ genericSequencer.createSequence(context, semanticObject);
+ }
+
+
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/serializer/IndentationAwareUiTestLanguageSyntacticSequencer.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/serializer/IndentationAwareUiTestLanguageSyntacticSequencer.java
new file mode 100644
index 0000000000..0311a65ba1
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/serializer/IndentationAwareUiTestLanguageSyntacticSequencer.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.serializer;
+
+import com.google.inject.Inject;
+import java.util.List;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.ide.tests.testlanguage.services.IndentationAwareUiTestLanguageGrammarAccess;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.GroupAlias;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias;
+import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable;
+import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition;
+import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer;
+
+@SuppressWarnings("all")
+public class IndentationAwareUiTestLanguageSyntacticSequencer extends AbstractSyntacticSequencer {
+
+ protected IndentationAwareUiTestLanguageGrammarAccess grammarAccess;
+ protected AbstractElementAlias match_TreeNode___INDENTTerminalRuleCall_1_0_DEDENTTerminalRuleCall_1_2__q;
+
+ @Inject
+ protected void init(IGrammarAccess access) {
+ grammarAccess = (IndentationAwareUiTestLanguageGrammarAccess) access;
+ match_TreeNode___INDENTTerminalRuleCall_1_0_DEDENTTerminalRuleCall_1_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getTreeNodeAccess().getINDENTTerminalRuleCall_1_0()), new TokenAlias(false, false, grammarAccess.getTreeNodeAccess().getDEDENTTerminalRuleCall_1_2()));
+ }
+
+ @Override
+ protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) {
+ if (ruleCall.getRule() == grammarAccess.getDEDENTRule())
+ return getDEDENTToken(semanticObject, ruleCall, node);
+ else if (ruleCall.getRule() == grammarAccess.getINDENTRule())
+ return getINDENTToken(semanticObject, ruleCall, node);
+ return "";
+ }
+
+ /**
+ * Synthetic terminal rule. The concrete syntax is to be specified by clients.
+ * Defaults to the empty string.
+ */
+ protected String getDEDENTToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; }
+
+ /**
+ * Synthetic terminal rule. The concrete syntax is to be specified by clients.
+ * Defaults to the empty string.
+ */
+ protected String getINDENTToken(EObject semanticObject, RuleCall ruleCall, INode node) { return ""; }
+
+ @Override
+ protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) {
+ if (transition.getAmbiguousSyntaxes().isEmpty()) return;
+ List transitionNodes = collectNodes(fromNode, toNode);
+ for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) {
+ List syntaxNodes = getNodesFor(transitionNodes, syntax);
+ if (match_TreeNode___INDENTTerminalRuleCall_1_0_DEDENTTerminalRuleCall_1_2__q.equals(syntax))
+ emit_TreeNode___INDENTTerminalRuleCall_1_0_DEDENTTerminalRuleCall_1_2__q(semanticObject, getLastNavigableState(), syntaxNodes);
+ else acceptNodes(getLastNavigableState(), syntaxNodes);
+ }
+ }
+
+ /**
+ * Ambiguous syntax:
+ * (INDENT DEDENT)?
+ *
+ * This ambiguous syntax occurs at:
+ * name=ID (ambiguity) (rule end)
+ */
+ protected void emit_TreeNode___INDENTTerminalRuleCall_1_0_DEDENTTerminalRuleCall_1_2__q(EObject semanticObject, ISynNavigable transition, List nodes) {
+ acceptNodes(transition, nodes);
+ }
+
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/services/IndentationAwareUiTestLanguageGrammarAccess.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/services/IndentationAwareUiTestLanguageGrammarAccess.java
new file mode 100644
index 0000000000..caf312650c
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/services/IndentationAwareUiTestLanguageGrammarAccess.java
@@ -0,0 +1,317 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.services;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.xtext.Action;
+import org.eclipse.xtext.Assignment;
+import org.eclipse.xtext.Grammar;
+import org.eclipse.xtext.GrammarUtil;
+import org.eclipse.xtext.Group;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.TerminalRule;
+import org.eclipse.xtext.common.services.TerminalsGrammarAccess;
+import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder;
+import org.eclipse.xtext.service.GrammarProvider;
+
+@Singleton
+public class IndentationAwareUiTestLanguageGrammarAccess extends AbstractGrammarElementFinder {
+
+ public class TreeElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.Tree");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cTreeAction_0 = (Action)cGroup.eContents().get(0);
+ private final Assignment cNodesAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cNodesTreeNodeParserRuleCall_1_0 = (RuleCall)cNodesAssignment_1.eContents().get(0);
+ private final Assignment cMoreNodesAssignment_2 = (Assignment)cGroup.eContents().get(2);
+ private final RuleCall cMoreNodesOtherTreeNodeParserRuleCall_2_0 = (RuleCall)cMoreNodesAssignment_2.eContents().get(0);
+
+ //Tree:
+ // {Tree} nodes+=TreeNode*
+ // moreNodes+=OtherTreeNode*;
+ @Override public ParserRule getRule() { return rule; }
+
+ //{Tree} nodes+=TreeNode* moreNodes+=OtherTreeNode*
+ public Group getGroup() { return cGroup; }
+
+ //{Tree}
+ public Action getTreeAction_0() { return cTreeAction_0; }
+
+ //nodes+=TreeNode*
+ public Assignment getNodesAssignment_1() { return cNodesAssignment_1; }
+
+ //TreeNode
+ public RuleCall getNodesTreeNodeParserRuleCall_1_0() { return cNodesTreeNodeParserRuleCall_1_0; }
+
+ //moreNodes+=OtherTreeNode*
+ public Assignment getMoreNodesAssignment_2() { return cMoreNodesAssignment_2; }
+
+ //OtherTreeNode
+ public RuleCall getMoreNodesOtherTreeNodeParserRuleCall_2_0() { return cMoreNodesOtherTreeNodeParserRuleCall_2_0; }
+ }
+ public class TreeNodeElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.TreeNode");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cNameAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cNameIDTerminalRuleCall_0_0 = (RuleCall)cNameAssignment_0.eContents().get(0);
+ private final Group cGroup_1 = (Group)cGroup.eContents().get(1);
+ private final RuleCall cINDENTTerminalRuleCall_1_0 = (RuleCall)cGroup_1.eContents().get(0);
+ private final Assignment cChildrenAssignment_1_1 = (Assignment)cGroup_1.eContents().get(1);
+ private final RuleCall cChildrenTreeNodeParserRuleCall_1_1_0 = (RuleCall)cChildrenAssignment_1_1.eContents().get(0);
+ private final RuleCall cDEDENTTerminalRuleCall_1_2 = (RuleCall)cGroup_1.eContents().get(2);
+
+ //TreeNode:
+ // name=ID (INDENT
+ // children+=TreeNode*
+ // DEDENT)?;
+ @Override public ParserRule getRule() { return rule; }
+
+ //name=ID (INDENT children+=TreeNode* DEDENT)?
+ public Group getGroup() { return cGroup; }
+
+ //name=ID
+ public Assignment getNameAssignment_0() { return cNameAssignment_0; }
+
+ //ID
+ public RuleCall getNameIDTerminalRuleCall_0_0() { return cNameIDTerminalRuleCall_0_0; }
+
+ //(INDENT children+=TreeNode* DEDENT)?
+ public Group getGroup_1() { return cGroup_1; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_1_0() { return cINDENTTerminalRuleCall_1_0; }
+
+ //children+=TreeNode*
+ public Assignment getChildrenAssignment_1_1() { return cChildrenAssignment_1_1; }
+
+ //TreeNode
+ public RuleCall getChildrenTreeNodeParserRuleCall_1_1_0() { return cChildrenTreeNodeParserRuleCall_1_1_0; }
+
+ //DEDENT
+ public RuleCall getDEDENTTerminalRuleCall_1_2() { return cDEDENTTerminalRuleCall_1_2; }
+ }
+ public class OtherTreeNodeElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.OtherTreeNode");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Assignment cNameAssignment_0 = (Assignment)cGroup.eContents().get(0);
+ private final RuleCall cNameSTRINGTerminalRuleCall_0_0 = (RuleCall)cNameAssignment_0.eContents().get(0);
+ private final Assignment cChildListAssignment_1 = (Assignment)cGroup.eContents().get(1);
+ private final RuleCall cChildListChildListParserRuleCall_1_0 = (RuleCall)cChildListAssignment_1.eContents().get(0);
+
+ //OtherTreeNode:
+ // name=STRING
+ // childList=ChildList?;
+ @Override public ParserRule getRule() { return rule; }
+
+ //name=STRING childList=ChildList?
+ public Group getGroup() { return cGroup; }
+
+ //name=STRING
+ public Assignment getNameAssignment_0() { return cNameAssignment_0; }
+
+ //STRING
+ public RuleCall getNameSTRINGTerminalRuleCall_0_0() { return cNameSTRINGTerminalRuleCall_0_0; }
+
+ //childList=ChildList?
+ public Assignment getChildListAssignment_1() { return cChildListAssignment_1; }
+
+ //ChildList
+ public RuleCall getChildListChildListParserRuleCall_1_0() { return cChildListChildListParserRuleCall_1_0; }
+ }
+ public class ChildListElements extends AbstractParserRuleElementFinder {
+ private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.ChildList");
+ private final Group cGroup = (Group)rule.eContents().get(1);
+ private final Action cChildListAction_0 = (Action)cGroup.eContents().get(0);
+ private final RuleCall cINDENTTerminalRuleCall_1 = (RuleCall)cGroup.eContents().get(1);
+ private final Assignment cChildrenAssignment_2 = (Assignment)cGroup.eContents().get(2);
+ private final RuleCall cChildrenOtherTreeNodeParserRuleCall_2_0 = (RuleCall)cChildrenAssignment_2.eContents().get(0);
+ private final RuleCall cDEDENTTerminalRuleCall_3 = (RuleCall)cGroup.eContents().get(3);
+
+ //ChildList:
+ // {ChildList} INDENT
+ // children+=OtherTreeNode+
+ // DEDENT;
+ @Override public ParserRule getRule() { return rule; }
+
+ //{ChildList} INDENT children+=OtherTreeNode+ DEDENT
+ public Group getGroup() { return cGroup; }
+
+ //{ChildList}
+ public Action getChildListAction_0() { return cChildListAction_0; }
+
+ //INDENT
+ public RuleCall getINDENTTerminalRuleCall_1() { return cINDENTTerminalRuleCall_1; }
+
+ //children+=OtherTreeNode+
+ public Assignment getChildrenAssignment_2() { return cChildrenAssignment_2; }
+
+ //OtherTreeNode
+ public RuleCall getChildrenOtherTreeNodeParserRuleCall_2_0() { return cChildrenOtherTreeNodeParserRuleCall_2_0; }
+
+ //DEDENT
+ public RuleCall getDEDENTTerminalRuleCall_3() { return cDEDENTTerminalRuleCall_3; }
+ }
+
+
+ private final TreeElements pTree;
+ private final TreeNodeElements pTreeNode;
+ private final OtherTreeNodeElements pOtherTreeNode;
+ private final ChildListElements pChildList;
+ private final TerminalRule tSL_COMMENT;
+ private final TerminalRule tINDENT;
+ private final TerminalRule tDEDENT;
+
+ private final Grammar grammar;
+
+ private final TerminalsGrammarAccess gaTerminals;
+
+ @Inject
+ public IndentationAwareUiTestLanguageGrammarAccess(GrammarProvider grammarProvider,
+ TerminalsGrammarAccess gaTerminals) {
+ this.grammar = internalFindGrammar(grammarProvider);
+ this.gaTerminals = gaTerminals;
+ this.pTree = new TreeElements();
+ this.pTreeNode = new TreeNodeElements();
+ this.pOtherTreeNode = new OtherTreeNodeElements();
+ this.pChildList = new ChildListElements();
+ this.tSL_COMMENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.SL_COMMENT");
+ this.tINDENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.INDENT");
+ this.tDEDENT = (TerminalRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage.DEDENT");
+ }
+
+ protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
+ Grammar grammar = grammarProvider.getGrammar(this);
+ while (grammar != null) {
+ if ("org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage".equals(grammar.getName())) {
+ return grammar;
+ }
+ List grammars = grammar.getUsedGrammars();
+ if (!grammars.isEmpty()) {
+ grammar = grammars.iterator().next();
+ } else {
+ return null;
+ }
+ }
+ return grammar;
+ }
+
+ @Override
+ public Grammar getGrammar() {
+ return grammar;
+ }
+
+
+ public TerminalsGrammarAccess getTerminalsGrammarAccess() {
+ return gaTerminals;
+ }
+
+
+ //Tree:
+ // {Tree} nodes+=TreeNode*
+ // moreNodes+=OtherTreeNode*;
+ public TreeElements getTreeAccess() {
+ return pTree;
+ }
+
+ public ParserRule getTreeRule() {
+ return getTreeAccess().getRule();
+ }
+
+ //TreeNode:
+ // name=ID (INDENT
+ // children+=TreeNode*
+ // DEDENT)?;
+ public TreeNodeElements getTreeNodeAccess() {
+ return pTreeNode;
+ }
+
+ public ParserRule getTreeNodeRule() {
+ return getTreeNodeAccess().getRule();
+ }
+
+ //OtherTreeNode:
+ // name=STRING
+ // childList=ChildList?;
+ public OtherTreeNodeElements getOtherTreeNodeAccess() {
+ return pOtherTreeNode;
+ }
+
+ public ParserRule getOtherTreeNodeRule() {
+ return getOtherTreeNodeAccess().getRule();
+ }
+
+ //ChildList:
+ // {ChildList} INDENT
+ // children+=OtherTreeNode+
+ // DEDENT;
+ public ChildListElements getChildListAccess() {
+ return pChildList;
+ }
+
+ public ParserRule getChildListRule() {
+ return getChildListAccess().getRule();
+ }
+
+ //@ Override terminal SL_COMMENT:
+ // '//' !('\n' | '\r')*;
+ public TerminalRule getSL_COMMENTRule() {
+ return tSL_COMMENT;
+ }
+
+ //terminal INDENT:
+ // 'synthetic:INDENT';
+ public TerminalRule getINDENTRule() {
+ return tINDENT;
+ }
+
+ //terminal DEDENT:
+ // 'synthetic:DEDENT';
+ public TerminalRule getDEDENTRule() {
+ return tDEDENT;
+ }
+
+ //terminal ID:
+ // '^'? ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*;
+ public TerminalRule getIDRule() {
+ return gaTerminals.getIDRule();
+ }
+
+ //terminal INT returns ecore::EInt:
+ // '0'..'9'+;
+ public TerminalRule getINTRule() {
+ return gaTerminals.getINTRule();
+ }
+
+ //terminal STRING:
+ // '"' ('\\' . | !('\\' | '"'))* '"' |
+ // "'" ('\\' . | !('\\' | "'"))* "'";
+ public TerminalRule getSTRINGRule() {
+ return gaTerminals.getSTRINGRule();
+ }
+
+ //terminal ML_COMMENT:
+ // '/*'->'*/';
+ public TerminalRule getML_COMMENTRule() {
+ return gaTerminals.getML_COMMENTRule();
+ }
+
+ //terminal WS:
+ // ' ' | '\t' | '\r' | '\n'+;
+ public TerminalRule getWSRule() {
+ return gaTerminals.getWSRule();
+ }
+
+ //terminal ANY_OTHER:
+ // .;
+ public TerminalRule getANY_OTHERRule() {
+ return gaTerminals.getANY_OTHERRule();
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/tests/IndentationAwareUiTestLanguageInjectorProvider.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/tests/IndentationAwareUiTestLanguageInjectorProvider.java
new file mode 100644
index 0000000000..11ba596ea5
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/tests/IndentationAwareUiTestLanguageInjectorProvider.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.tests;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguageRuntimeModule;
+import org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguageStandaloneSetup;
+import org.eclipse.xtext.testing.GlobalRegistries;
+import org.eclipse.xtext.testing.GlobalRegistries.GlobalStateMemento;
+import org.eclipse.xtext.testing.IInjectorProvider;
+import org.eclipse.xtext.testing.IRegistryConfigurator;
+
+public class IndentationAwareUiTestLanguageInjectorProvider implements IInjectorProvider, IRegistryConfigurator {
+
+ protected GlobalStateMemento stateBeforeInjectorCreation;
+ protected GlobalStateMemento stateAfterInjectorCreation;
+ protected Injector injector;
+
+ static {
+ GlobalRegistries.initializeDefaults();
+ }
+
+ @Override
+ public Injector getInjector() {
+ if (injector == null) {
+ stateBeforeInjectorCreation = GlobalRegistries.makeCopyOfGlobalState();
+ this.injector = internalCreateInjector();
+ stateAfterInjectorCreation = GlobalRegistries.makeCopyOfGlobalState();
+ }
+ return injector;
+ }
+
+ protected Injector internalCreateInjector() {
+ return new IndentationAwareUiTestLanguageStandaloneSetup() {
+ @Override
+ public Injector createInjector() {
+ return Guice.createInjector(createRuntimeModule());
+ }
+ }.createInjectorAndDoEMFRegistration();
+ }
+
+ protected IndentationAwareUiTestLanguageRuntimeModule createRuntimeModule() {
+ // make it work also with Maven/Tycho and OSGI
+ // see https://bugs.eclipse.org/bugs/show_bug.cgi?id=493672
+ return new IndentationAwareUiTestLanguageRuntimeModule() {
+ @Override
+ public ClassLoader bindClassLoaderToInstance() {
+ return IndentationAwareUiTestLanguageInjectorProvider.class
+ .getClassLoader();
+ }
+ };
+ }
+
+ @Override
+ public void restoreRegistry() {
+ stateBeforeInjectorCreation.restoreGlobalState();
+ }
+
+ @Override
+ public void setupRegistry() {
+ getInjector();
+ stateAfterInjectorCreation.restoreGlobalState();
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/validation/AbstractIndentationAwareUiTestLanguageValidator.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/validation/AbstractIndentationAwareUiTestLanguageValidator.java
new file mode 100644
index 0000000000..0d23512c95
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/validation/AbstractIndentationAwareUiTestLanguageValidator.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.validation;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.xtext.validation.AbstractDeclarativeValidator;
+
+public abstract class AbstractIndentationAwareUiTestLanguageValidator extends AbstractDeclarativeValidator {
+
+ @Override
+ protected List getEPackages() {
+ List result = new ArrayList();
+ result.add(org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.IndentationAwareUiTestLanguagePackage.eINSTANCE);
+ return result;
+ }
+
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/GenerateTestLanguage.mwe2 b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/GenerateTestLanguage.mwe2
index 0cff548a73..eb8abaf217 100644
--- a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/GenerateTestLanguage.mwe2
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/GenerateTestLanguage.mwe2
@@ -65,6 +65,20 @@ Workflow {
generateStub = false
}
}
+ language = StandardLanguage {
+ name = "org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage"
+ fileExtensions = "indentationAwareUiTestLang"
+
+ serializer = {
+ generateStub = false
+ }
+ validator = {
+ // composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator"
+ }
+ junitSupport = {
+ generateStub = false
+ }
+ }
language = StandardLanguage {
name = "org.eclipse.xtext.ide.tests.testlanguage.PartialContentAssistTestLanguage"
fileExtensions = "partialcontentassisttestlang"
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguage.xtext b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguage.xtext
new file mode 100644
index 0000000000..c424049e2f
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguage.xtext
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2017 itemis AG (http://www.itemis.de) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+grammar org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguage with org.eclipse.xtext.common.Terminals
+
+generate indentationAwareUiTestLanguage "http://www.eclipse.org/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguage"
+
+Tree: {Tree}
+ nodes+=TreeNode*
+ moreNodes+=OtherTreeNode*
+;
+
+TreeNode:
+ name=ID
+ (INDENT
+ children+=TreeNode*
+ DEDENT)?
+;
+
+OtherTreeNode:
+ name=STRING
+ childList = ChildList?
+;
+
+ChildList: {ChildList}
+ INDENT
+ children+=OtherTreeNode+
+ DEDENT
+;
+
+@Override
+terminal SL_COMMENT: '//' !('\n'|'\r')*;
+
+terminal INDENT: 'synthetic:INDENT';
+terminal DEDENT: 'synthetic:DEDENT';
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageRuntimeModule.xtend b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageRuntimeModule.xtend
new file mode 100644
index 0000000000..e0fee87f3f
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageRuntimeModule.xtend
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage
+
+
+/**
+ * Use this class to register components to be used at runtime / without the Equinox extension registry.
+ */
+class IndentationAwareUiTestLanguageRuntimeModule extends AbstractIndentationAwareUiTestLanguageRuntimeModule {
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageStandaloneSetup.xtend b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageStandaloneSetup.xtend
new file mode 100644
index 0000000000..75de31391e
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageStandaloneSetup.xtend
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage
+
+
+/**
+ * Initialization support for running Xtext languages without Equinox extension registry.
+ */
+class IndentationAwareUiTestLanguageStandaloneSetup extends IndentationAwareUiTestLanguageStandaloneSetupGenerated {
+
+ def static void doSetup() {
+ new IndentationAwareUiTestLanguageStandaloneSetup().createInjectorAndDoEMFRegistration()
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/generator/IndentationAwareUiTestLanguageGenerator.xtend b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/generator/IndentationAwareUiTestLanguageGenerator.xtend
new file mode 100644
index 0000000000..1b85277ae1
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/generator/IndentationAwareUiTestLanguageGenerator.xtend
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.generator
+
+import org.eclipse.emf.ecore.resource.Resource
+import org.eclipse.xtext.generator.AbstractGenerator
+import org.eclipse.xtext.generator.IFileSystemAccess2
+import org.eclipse.xtext.generator.IGeneratorContext
+
+/**
+ * Generates code from your model files on save.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation
+ */
+class IndentationAwareUiTestLanguageGenerator extends AbstractGenerator {
+
+ override void doGenerate(Resource resource, IFileSystemAccess2 fsa, IGeneratorContext context) {
+// fsa.generateFile('greetings.txt', 'People to greet: ' +
+// resource.allContents
+// .filter(Greeting)
+// .map[name]
+// .join(', '))
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeModule.xtend b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeModule.xtend
new file mode 100644
index 0000000000..06786675ec
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeModule.xtend
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.ide
+
+
+/**
+ * Use this class to register ide components.
+ */
+class IndentationAwareUiTestLanguageIdeModule extends AbstractIndentationAwareUiTestLanguageIdeModule {
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeSetup.xtend b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeSetup.xtend
new file mode 100644
index 0000000000..05d3fdfb1b
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeSetup.xtend
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.ide
+
+import com.google.inject.Guice
+import org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguageRuntimeModule
+import org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguageStandaloneSetup
+import org.eclipse.xtext.util.Modules2
+
+/**
+ * Initialization support for running Xtext languages as language servers.
+ */
+class IndentationAwareUiTestLanguageIdeSetup extends IndentationAwareUiTestLanguageStandaloneSetup {
+
+ override createInjector() {
+ Guice.createInjector(Modules2.mixin(new IndentationAwareUiTestLanguageRuntimeModule, new IndentationAwareUiTestLanguageIdeModule))
+ }
+
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/ide/contentassist/antlr/IndentationAwareUiTestLanguageTokenSource.java b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/ide/contentassist/antlr/IndentationAwareUiTestLanguageTokenSource.java
new file mode 100644
index 0000000000..9a64d8cb4e
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/ide/contentassist/antlr/IndentationAwareUiTestLanguageTokenSource.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.ide.contentassist.antlr;
+
+import org.antlr.runtime.Token;
+import org.antlr.runtime.TokenSource;
+import org.eclipse.xtext.ide.tests.testlanguage.ide.contentassist.antlr.internal.InternalIndentationAwareUiTestLanguageParser;
+import org.eclipse.xtext.parser.antlr.AbstractIndentationTokenSource;
+
+public class IndentationAwareUiTestLanguageTokenSource extends AbstractIndentationTokenSource {
+
+ public IndentationAwareUiTestLanguageTokenSource(TokenSource delegate) {
+ super(delegate);
+ }
+
+ @Override
+ protected boolean shouldSplitTokenImpl(Token token) {
+ // TODO Review assumption
+ return token.getType() == InternalIndentationAwareUiTestLanguageParser.RULE_WS;
+ }
+
+ @Override
+ protected int getBeginTokenType() {
+ // TODO Review assumption
+ return InternalIndentationAwareUiTestLanguageParser.RULE_INDENT;
+ }
+
+ @Override
+ protected int getEndTokenType() {
+ // TODO Review assumption
+ return InternalIndentationAwareUiTestLanguageParser.RULE_DEDENT;
+ }
+
+ @Override
+ protected boolean shouldEmitPendingEndTokens() {
+ return false;
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/IndentationAwareUiTestLanguageTokenSource.java b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/IndentationAwareUiTestLanguageTokenSource.java
new file mode 100644
index 0000000000..928456582d
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/parser/antlr/IndentationAwareUiTestLanguageTokenSource.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.parser.antlr;
+
+import org.antlr.runtime.Token;
+import org.antlr.runtime.TokenSource;
+import org.eclipse.xtext.ide.tests.testlanguage.parser.antlr.internal.InternalIndentationAwareUiTestLanguageParser;
+import org.eclipse.xtext.parser.antlr.AbstractIndentationTokenSource;
+
+public class IndentationAwareUiTestLanguageTokenSource extends AbstractIndentationTokenSource {
+
+ public IndentationAwareUiTestLanguageTokenSource(TokenSource delegate) {
+ super(delegate);
+ }
+
+ @Override
+ protected boolean shouldSplitTokenImpl(Token token) {
+ // TODO Review assumption
+ return token.getType() == InternalIndentationAwareUiTestLanguageParser.RULE_WS;
+ }
+
+ @Override
+ protected int getBeginTokenType() {
+ // TODO Review assumption
+ return InternalIndentationAwareUiTestLanguageParser.RULE_INDENT;
+ }
+
+ @Override
+ protected int getEndTokenType() {
+ // TODO Review assumption
+ return InternalIndentationAwareUiTestLanguageParser.RULE_DEDENT;
+ }
+
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/scoping/IndentationAwareUiTestLanguageScopeProvider.xtend b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/scoping/IndentationAwareUiTestLanguageScopeProvider.xtend
new file mode 100644
index 0000000000..2c9f847b48
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/scoping/IndentationAwareUiTestLanguageScopeProvider.xtend
@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.scoping
+
+
+/**
+ * This class contains custom scoping description.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping
+ * on how and when to use it.
+ */
+class IndentationAwareUiTestLanguageScopeProvider extends AbstractIndentationAwareUiTestLanguageScopeProvider {
+
+}
diff --git a/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/validation/IndentationAwareUiTestLanguageValidator.xtend b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/validation/IndentationAwareUiTestLanguageValidator.xtend
new file mode 100644
index 0000000000..0172a14c60
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/testlang-src/org/eclipse/xtext/ide/tests/testlanguage/validation/IndentationAwareUiTestLanguageValidator.xtend
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.validation
+
+
+/**
+ * This class contains custom validation rules.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation
+ */
+class IndentationAwareUiTestLanguageValidator extends AbstractIndentationAwareUiTestLanguageValidator {
+
+// public static val INVALID_NAME = 'invalidName'
+//
+// @Check
+// def checkGreetingStartsWithCapital(Greeting greeting) {
+// if (!Character.isUpperCase(greeting.name.charAt(0))) {
+// warning('Name should start with a capital',
+// IndentationAwareUiTestLanguagePackage.Literals.GREETING__NAME,
+// INVALID_NAME)
+// }
+// }
+
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/AbstractCompletePrefixProviderTest.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/AbstractCompletePrefixProviderTest.java
new file mode 100644
index 0000000000..fe87ca84c4
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/AbstractCompletePrefixProviderTest.java
@@ -0,0 +1,1798 @@
+/**
+ * Copyright (c) 2017 itemis AG (http://www.itemis.de) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.indentation;
+
+import com.google.common.base.Objects;
+import com.google.inject.Inject;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.AbstractRule;
+import org.eclipse.xtext.Action;
+import org.eclipse.xtext.Keyword;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider;
+import org.eclipse.xtext.ide.tests.testlanguage.indentationAwareUiTestLanguage.Tree;
+import org.eclipse.xtext.nodemodel.ICompositeNode;
+import org.eclipse.xtext.nodemodel.ILeafNode;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.nodemodel.util.NodeModelUtils;
+import org.eclipse.xtext.testing.util.ParseHelper;
+import org.eclipse.xtext.xbase.lib.Exceptions;
+import org.eclipse.xtext.xbase.lib.Functions.Function1;
+import org.eclipse.xtext.xbase.lib.IterableExtensions;
+import org.junit.Assert;
+import org.junit.Test;
+
+/**
+ * @author Sebastian Zarnekow - Initial contribution and API
+ */
+@SuppressWarnings("all")
+public abstract class AbstractCompletePrefixProviderTest {
+ public abstract CompletionPrefixProvider getTestee();
+
+ @Inject
+ private ParseHelper parseHelper;
+
+ @Test
+ public void testInputToParse_01() {
+ Assert.assertEquals("abc", this.getTestee().getInputToParse("abcdefg", 3, 7));
+ }
+
+ @Test
+ public void testInputToParse_02() {
+ Assert.assertEquals("abc", this.getTestee().getInputToParse("abc defg", 3, 7));
+ }
+
+ @Test
+ public void testWholeNodeModel() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild2");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("grandChild3");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("grandChild4");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child2");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild5");
+ _builder.newLine();
+ _builder.append("parent2");
+ _builder.newLine();
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild2]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild3]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild4]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child2]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild5]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:parent2]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_0_0() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("<|>parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_0_2() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("pa<|>rent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_1_0() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("<|>\tchild1");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_1_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>child1");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_1_2() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c<|>hild1");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_2_0() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("<|>\t\tgrandChild1");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_2_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>\tgrandChild1");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_2_2() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>grandChild1");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_3_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_3_2() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>grandChild2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_2() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_0() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_2b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_1b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_0b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_2c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_1c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_0c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_2d() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("parent2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_1d() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("parent2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_4_0d() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("parent2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_6_0() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_6_0b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("f");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_6_1b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("f");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_5_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_6_3() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g <|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_6_3b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g <|>");
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_6_3c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g <|> ");
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_6_3d() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g <|> // comment");
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_7_0() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_7_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_8_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_8_2() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_8_2b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_8_2c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_8_3() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_8_3b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_8_3c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_8_4() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_8_4b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ public void testLastCompleteNode_8_4c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ protected void assertLastCompleteNode(final CharSequence model, final String expectation) {
+ final String modelAsString = model.toString();
+ this.assertLastCompleteNode(modelAsString, expectation);
+ final String withStringLiterals = modelAsString.replaceAll("(\\w+(<\\|>\\w+)?)", "\"$1\"");
+ final String expectationWithLiterals = expectation.replaceAll("ID:(\\w+)", "STRING:\"$1\"");
+ this.assertLastCompleteNode(withStringLiterals, expectationWithLiterals);
+ }
+
+ private void assertLastCompleteNode(final String model, final String expectation) {
+ try {
+ int offset = model.indexOf("<|>");
+ if ((offset == (-1))) {
+ offset = model.length();
+ }
+ int completionOffset = model.indexOf("<|>", offset);
+ if ((completionOffset == (-1))) {
+ completionOffset = offset;
+ }
+ final Tree tree = this.parseHelper.parse(model.replace("<|>", ""));
+ final ICompositeNode nodeModel = NodeModelUtils.findActualNodeFor(tree);
+ final INode completeNode = this.getTestee().getLastCompleteNodeByOffset(nodeModel, offset, completionOffset);
+ this.assertNodeModel(expectation, completeNode);
+ } catch (Throwable _e) {
+ throw Exceptions.sneakyThrow(_e);
+ }
+ }
+
+ private void assertNodeModel(final String expectation, final INode node) {
+ Assert.assertEquals(expectation, this.asText(node.getRootNode(), node));
+ }
+
+ private String asText(final INode node, final INode stop) {
+ StringConcatenation _builder = new StringConcatenation();
+ {
+ final Function1 _function = (ILeafNode it) -> {
+ EObject _grammarElement = it.getGrammarElement();
+ return Boolean.valueOf((!(_grammarElement instanceof Action)));
+ };
+ final Function1 _function_1 = (ILeafNode it) -> {
+ boolean _isHidden = it.isHidden();
+ return Boolean.valueOf((!_isHidden));
+ };
+ Iterable _upTo = this.upTo(IterableExtensions.filter(IterableExtensions.filter(node.getLeafNodes(), _function), _function_1), stop);
+ for(final ILeafNode leaf : _upTo) {
+ _builder.append("[");
+ String _kenType = this.tokenType(leaf.getGrammarElement());
+ _builder.append(_kenType);
+ _builder.append(":");
+ String _replace = leaf.getText().replace("\t", "\\t");
+ _builder.append(_replace);
+ _builder.append("]");
+ _builder.newLineIfNotEmpty();
+ }
+ }
+ return _builder.toString();
+ }
+
+ private Iterable upTo(final Iterable iter, final Object element) {
+ abstract class __AbstractCompletePrefixProviderTest_1 implements Function1 {
+ boolean found;
+ }
+
+ __AbstractCompletePrefixProviderTest_1 ___AbstractCompletePrefixProviderTest_1 = new __AbstractCompletePrefixProviderTest_1() {
+ {
+ found = false;
+ }
+ @Override
+ public Boolean apply(final T t) {
+ if (this.found) {
+ return Boolean.valueOf(false);
+ }
+ try {
+ return Boolean.valueOf(true);
+ } finally {
+ boolean _equals = Objects.equal(t, element);
+ this.found = _equals;
+ }
+ }
+ };
+ return IterableExtensions.filter(iter, ___AbstractCompletePrefixProviderTest_1);
+ }
+
+ private String tokenType(final EObject obj) {
+ String _switchResult = null;
+ boolean _matched = false;
+ if (obj instanceof RuleCall) {
+ _matched=true;
+ _switchResult = ((RuleCall)obj).getRule().getName();
+ }
+ if (!_matched) {
+ if (obj instanceof Keyword) {
+ _matched=true;
+ _switchResult = ((Keyword)obj).getValue();
+ }
+ }
+ if (!_matched) {
+ if (obj instanceof AbstractRule) {
+ _matched=true;
+ _switchResult = ((AbstractRule)obj).getName();
+ }
+ }
+ return _switchResult;
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/CompletionPrefixProviderTest.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/CompletionPrefixProviderTest.java
new file mode 100644
index 0000000000..2aaa261fb1
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/CompletionPrefixProviderTest.java
@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2017 itemis AG (http://www.itemis.de) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.indentation;
+
+import com.google.inject.Inject;
+import org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider;
+import org.eclipse.xtext.ide.tests.indentation.AbstractCompletePrefixProviderTest;
+import org.eclipse.xtext.ide.tests.testlanguage.tests.IndentationAwareUiTestLanguageInjectorProvider;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.XtextRunner;
+import org.junit.runner.RunWith;
+
+/**
+ * @author Sebastian Zarnekow - Initial contribution and API
+ */
+@RunWith(XtextRunner.class)
+@InjectWith(IndentationAwareUiTestLanguageInjectorProvider.class)
+@SuppressWarnings("all")
+public class CompletionPrefixProviderTest extends AbstractCompletePrefixProviderTest {
+ @Inject
+ private CompletionPrefixProvider testee;
+
+ @Override
+ public CompletionPrefixProvider getTestee() {
+ return this.testee;
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwareCompletionPrefixProviderTest.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwareCompletionPrefixProviderTest.java
new file mode 100644
index 0000000000..b3da96adf8
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwareCompletionPrefixProviderTest.java
@@ -0,0 +1,1258 @@
+/**
+ * Copyright (c) 2017 itemis AG (http://www.itemis.de) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.indentation;
+
+import com.google.inject.Inject;
+import org.eclipse.xtend2.lib.StringConcatenation;
+import org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider;
+import org.eclipse.xtext.ide.editor.contentassist.IndentationAwareCompletionPrefixProvider;
+import org.eclipse.xtext.ide.tests.indentation.AbstractCompletePrefixProviderTest;
+import org.eclipse.xtext.ide.tests.testlanguage.tests.IndentationAwareUiTestLanguageInjectorProvider;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.XtextRunner;
+import org.junit.Assert;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+/**
+ * @author Sebastian Zarnekow - Initial contribution and API
+ */
+@RunWith(XtextRunner.class)
+@InjectWith(IndentationAwareUiTestLanguageInjectorProvider.class)
+@SuppressWarnings("all")
+public class IndentationAwareCompletionPrefixProviderTest extends AbstractCompletePrefixProviderTest {
+ @Inject
+ private IndentationAwareCompletionPrefixProvider testee;
+
+ @Override
+ public CompletionPrefixProvider getTestee() {
+ return this.testee;
+ }
+
+ @Test
+ @Override
+ public void testInputToParse_02() {
+ Assert.assertEquals("abc ", this.testee.getInputToParse("abc defg", 3, 5));
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_1_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild2");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("grandChild3");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("grandChild4");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child2");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild5");
+ _builder.newLine();
+ _builder.append("parent2");
+ _builder.newLine();
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_2_2() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild2");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("grandChild3");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("grandChild4");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child2");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild5");
+ _builder.newLine();
+ _builder.append("parent2");
+ _builder.newLine();
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_3_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_4_2() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_4_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_4_1b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild2]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_4_0() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_4_0c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_4_0d() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("parent2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_4_1d() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("parent2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_4_2c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_4_2d() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("parent1");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("child1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("grandChild1");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("parent2");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:parent1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:child1]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:grandChild1]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_6_0() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_6_0b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("f");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_5_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_7_0() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_7_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_8_1() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_8_2() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_8_2b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_8_2c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_8_3() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_8_3b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_8_3c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_8_4() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_8_4b() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+
+ @Test
+ @Override
+ public void testLastCompleteNode_8_4c() {
+ StringConcatenation _builder = new StringConcatenation();
+ _builder.append("a");
+ _builder.newLine();
+ _builder.append("b");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("c");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("d");
+ _builder.newLine();
+ _builder.append("\t\t\t");
+ _builder.append("e");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("f");
+ _builder.newLine();
+ _builder.append("\t\t");
+ _builder.append("g");
+ _builder.newLine();
+ _builder.append("\t\t\t\t");
+ _builder.append("<|>");
+ _builder.newLine();
+ _builder.append("\t");
+ _builder.append("h");
+ _builder.newLine();
+ StringConcatenation _builder_1 = new StringConcatenation();
+ _builder_1.append("[ID:a]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:b]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:c]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:d]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:e]");
+ _builder_1.newLine();
+ _builder_1.append("[INDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:f]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[DEDENT:]");
+ _builder_1.newLine();
+ _builder_1.append("[ID:g]");
+ _builder_1.newLine();
+ this.assertLastCompleteNode(_builder, _builder_1.toString());
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingTest.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingTest.java
new file mode 100644
index 0000000000..2b97bf010d
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingTest.java
@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2015 itemis AG (http://www.itemis.eu) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.indentation;
+
+import org.eclipse.xtext.ide.tests.indentation.CompletionPrefixProviderTest;
+import org.eclipse.xtext.testing.smoketest.ProcessedBy;
+import org.eclipse.xtext.testing.smoketest.XtextSmokeTestRunner;
+import org.eclipse.xtext.testing.smoketest.processors.PartialParsingProcessor;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+/**
+ * @author Sebastian Zarnekow - Initial contribution and API
+ */
+@RunWith(XtextSmokeTestRunner.class)
+@ProcessedBy(value = PartialParsingProcessor.class, processInParallel = true)
+@Suite.SuiteClasses(CompletionPrefixProviderTest.class)
+@SuppressWarnings("all")
+public class IndentationAwarePartialParsingTest {
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageRuntimeModule.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageRuntimeModule.java
new file mode 100644
index 0000000000..43835299d2
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageRuntimeModule.java
@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage;
+
+import org.eclipse.xtext.ide.tests.testlanguage.AbstractIndentationAwareUiTestLanguageRuntimeModule;
+
+/**
+ * Use this class to register components to be used at runtime / without the Equinox extension registry.
+ */
+@SuppressWarnings("all")
+public class IndentationAwareUiTestLanguageRuntimeModule extends AbstractIndentationAwareUiTestLanguageRuntimeModule {
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageStandaloneSetup.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageStandaloneSetup.java
new file mode 100644
index 0000000000..463a42c9fa
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/IndentationAwareUiTestLanguageStandaloneSetup.java
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage;
+
+import org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguageStandaloneSetupGenerated;
+
+/**
+ * Initialization support for running Xtext languages without Equinox extension registry.
+ */
+@SuppressWarnings("all")
+public class IndentationAwareUiTestLanguageStandaloneSetup extends IndentationAwareUiTestLanguageStandaloneSetupGenerated {
+ public static void doSetup() {
+ new IndentationAwareUiTestLanguageStandaloneSetup().createInjectorAndDoEMFRegistration();
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/generator/IndentationAwareUiTestLanguageGenerator.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/generator/IndentationAwareUiTestLanguageGenerator.java
new file mode 100644
index 0000000000..dc414795e9
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/generator/IndentationAwareUiTestLanguageGenerator.java
@@ -0,0 +1,25 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.generator;
+
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.generator.AbstractGenerator;
+import org.eclipse.xtext.generator.IFileSystemAccess2;
+import org.eclipse.xtext.generator.IGeneratorContext;
+
+/**
+ * Generates code from your model files on save.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#code-generation
+ */
+@SuppressWarnings("all")
+public class IndentationAwareUiTestLanguageGenerator extends AbstractGenerator {
+ @Override
+ public void doGenerate(final Resource resource, final IFileSystemAccess2 fsa, final IGeneratorContext context) {
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeModule.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeModule.java
new file mode 100644
index 0000000000..4b98dfe252
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeModule.java
@@ -0,0 +1,17 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.ide;
+
+import org.eclipse.xtext.ide.tests.testlanguage.ide.AbstractIndentationAwareUiTestLanguageIdeModule;
+
+/**
+ * Use this class to register ide components.
+ */
+@SuppressWarnings("all")
+public class IndentationAwareUiTestLanguageIdeModule extends AbstractIndentationAwareUiTestLanguageIdeModule {
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeSetup.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeSetup.java
new file mode 100644
index 0000000000..e07f9e9feb
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/ide/IndentationAwareUiTestLanguageIdeSetup.java
@@ -0,0 +1,28 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.ide;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguageRuntimeModule;
+import org.eclipse.xtext.ide.tests.testlanguage.IndentationAwareUiTestLanguageStandaloneSetup;
+import org.eclipse.xtext.ide.tests.testlanguage.ide.IndentationAwareUiTestLanguageIdeModule;
+import org.eclipse.xtext.util.Modules2;
+
+/**
+ * Initialization support for running Xtext languages as language servers.
+ */
+@SuppressWarnings("all")
+public class IndentationAwareUiTestLanguageIdeSetup extends IndentationAwareUiTestLanguageStandaloneSetup {
+ @Override
+ public Injector createInjector() {
+ IndentationAwareUiTestLanguageRuntimeModule _indentationAwareUiTestLanguageRuntimeModule = new IndentationAwareUiTestLanguageRuntimeModule();
+ IndentationAwareUiTestLanguageIdeModule _indentationAwareUiTestLanguageIdeModule = new IndentationAwareUiTestLanguageIdeModule();
+ return Guice.createInjector(Modules2.mixin(_indentationAwareUiTestLanguageRuntimeModule, _indentationAwareUiTestLanguageIdeModule));
+ }
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/scoping/IndentationAwareUiTestLanguageScopeProvider.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/scoping/IndentationAwareUiTestLanguageScopeProvider.java
new file mode 100644
index 0000000000..29083138b7
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/scoping/IndentationAwareUiTestLanguageScopeProvider.java
@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.scoping;
+
+import org.eclipse.xtext.ide.tests.testlanguage.scoping.AbstractIndentationAwareUiTestLanguageScopeProvider;
+
+/**
+ * This class contains custom scoping description.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping
+ * on how and when to use it.
+ */
+@SuppressWarnings("all")
+public class IndentationAwareUiTestLanguageScopeProvider extends AbstractIndentationAwareUiTestLanguageScopeProvider {
+}
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/validation/IndentationAwareUiTestLanguageValidator.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/validation/IndentationAwareUiTestLanguageValidator.java
new file mode 100644
index 0000000000..adac891ae7
--- /dev/null
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/testlanguage/validation/IndentationAwareUiTestLanguageValidator.java
@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2016 TypeFox GmbH (http://www.typefox.io) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.ide.tests.testlanguage.validation;
+
+import org.eclipse.xtext.ide.tests.testlanguage.validation.AbstractIndentationAwareUiTestLanguageValidator;
+
+/**
+ * This class contains custom validation rules.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation
+ */
+@SuppressWarnings("all")
+public class IndentationAwareUiTestLanguageValidator extends AbstractIndentationAwareUiTestLanguageValidator {
+}
From b97610216214158feb447e64a3202fa06c0698b0 Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Mon, 12 Jun 2017 15:16:27 +0200
Subject: [PATCH 07/17] Made proposal conflict helper more robust
---
.../xtext/ide/editor/contentassist/ProposalConflictHelper.java | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/ProposalConflictHelper.java b/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/ProposalConflictHelper.java
index d3c45bd337..191b8d4a96 100644
--- a/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/ProposalConflictHelper.java
+++ b/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/ProposalConflictHelper.java
@@ -52,7 +52,8 @@ public boolean existsConflict(String proposal, ContentAssistContext context) {
public boolean existsConflict(INode lastCompleteNode, int offset, String proposal, ContentAssistContext context) {
String lastCompleteText = lastCompleteNode.getText();
- lastCompleteText = lastCompleteText.substring(0, offset - lastCompleteNode.getTotalOffset());
+ int endOffset = offset - lastCompleteNode.getTotalOffset();
+ lastCompleteText = lastCompleteText.substring(0, Math.max(endOffset, 0));
if (Strings.isEmpty(lastCompleteText))
return false;
return existsConflict(lastCompleteText, proposal, context);
From 550eede373deede5b09e90d48ad4fdb3b97de6b5 Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Mon, 12 Jun 2017 15:24:23 +0200
Subject: [PATCH 08/17] Adjustments to XtextAntlrGeneratorFragment
---
.../antlr/XtextAntlrGeneratorFragment2.xtend | 25 +++++++++--
.../antlr/XtextAntlrGeneratorFragment2.java | 44 +++++++++++--------
2 files changed, 47 insertions(+), 22 deletions(-)
diff --git a/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/parser/antlr/XtextAntlrGeneratorFragment2.xtend b/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/parser/antlr/XtextAntlrGeneratorFragment2.xtend
index f5820d0cea..b6093a8133 100644
--- a/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/parser/antlr/XtextAntlrGeneratorFragment2.xtend
+++ b/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator/parser/antlr/XtextAntlrGeneratorFragment2.xtend
@@ -86,7 +86,7 @@ class XtextAntlrGeneratorFragment2 extends AbstractAntlrGeneratorFragment2 {
if (combinedGrammar.isSet)
combinedGrammar.get
else
- !options.backtrackLexer && !options.ignoreCase && !grammar.allTerminalRules.exists[isSyntheticTerminalRule]
+ !options.backtrackLexer && !options.ignoreCase && !hasSyntheticTerminalRule
}
override protected doGenerate() {
@@ -103,7 +103,7 @@ class XtextAntlrGeneratorFragment2 extends AbstractAntlrGeneratorFragment2 {
generateProductionParser().writeTo(projectConfig.runtime.srcGen)
generateAntlrTokenFileProvider().writeTo(projectConfig.runtime.srcGen)
generateContentAssistParser().writeTo(projectConfig.genericIde.srcGen)
- if (grammar.allTerminalRules.exists[ isSyntheticTerminalRule ]) {
+ if (hasSyntheticTerminalRule()) {
generateProductionTokenSource().writeTo(projectConfig.runtime.src)
generateContentAssistTokenSource().writeTo(projectConfig.genericIde.src)
}
@@ -112,6 +112,10 @@ class XtextAntlrGeneratorFragment2 extends AbstractAntlrGeneratorFragment2 {
addUiBindingsAndImports()
}
+ protected def boolean hasSyntheticTerminalRule() {
+ grammar.allTerminalRules.exists[ isSyntheticTerminalRule ]
+ }
+
def void setLookaheadThreshold(String lookaheadThreshold) {
this.lookaheadThreshold = Integer.parseInt(lookaheadThreshold)
}
@@ -194,7 +198,7 @@ class XtextAntlrGeneratorFragment2 extends AbstractAntlrGeneratorFragment2 {
tokenStream.setInitialHiddenTokens(«FOR hidden : grammar.initialHiddenTokens SEPARATOR ", "»"«hidden»"«ENDFOR»);
}
- «IF grammar.allTerminalRules.exists[isSyntheticTerminalRule]»
+ «IF hasSyntheticTerminalRule»
@Override
protected «TokenSource» createLexer(«CharStream» stream) {
return new «grammar.tokenSourceClass»(super.createLexer(stream));
@@ -316,7 +320,7 @@ class XtextAntlrGeneratorFragment2 extends AbstractAntlrGeneratorFragment2 {
return result;
}
- «IF grammar.allTerminalRules.exists[isSyntheticTerminalRule]»
+ «IF hasSyntheticTerminalRule»
@Override
protected «TokenSource» createLexer(«CharStream» stream) {
return new «grammar.tokenSourceClass»(super.createLexer(stream));
@@ -485,6 +489,12 @@ class XtextAntlrGeneratorFragment2 extends AbstractAntlrGeneratorFragment2 {
"org.eclipse.xtext.ide.editor.contentassist.antlr.PartialContentAssistContextFactory".typeRef
)
}
+ if (hasSyntheticTerminalRule) {
+ ideBindings.addTypeToType(
+ "org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider".typeRef,
+ "org.eclipse.xtext.ide.editor.contentassist.IndentationAwareCompletionPrefixProvider".typeRef
+ )
+ }
ideBindings.contributeTo(language.ideGenModule)
}
@@ -535,6 +545,13 @@ class XtextAntlrGeneratorFragment2 extends AbstractAntlrGeneratorFragment2 {
.addConfiguredBinding("ContentAssistLexerProvider", '''
binder.bind(«caLexerClass».class).toProvider(«LexerProvider».create(«caLexerClass».class));
''')
+
+ if (hasSyntheticTerminalRule) {
+ uiBindings.addTypeToType(
+ "org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider".typeRef,
+ "org.eclipse.xtext.ide.editor.contentassist.IndentationAwareCompletionPrefixProvider".typeRef
+ )
+ }
uiBindings.contributeTo(language.eclipsePluginGenModule)
}
diff --git a/org.eclipse.xtext.xtext.generator/xtend-gen/org/eclipse/xtext/xtext/generator/parser/antlr/XtextAntlrGeneratorFragment2.java b/org.eclipse.xtext.xtext.generator/xtend-gen/org/eclipse/xtext/xtext/generator/parser/antlr/XtextAntlrGeneratorFragment2.java
index 3958209a52..f5610dbec9 100644
--- a/org.eclipse.xtext.xtext.generator/xtend-gen/org/eclipse/xtext/xtext/generator/parser/antlr/XtextAntlrGeneratorFragment2.java
+++ b/org.eclipse.xtext.xtext.generator/xtend-gen/org/eclipse/xtext/xtext/generator/parser/antlr/XtextAntlrGeneratorFragment2.java
@@ -132,9 +132,7 @@ protected boolean isCombinedGrammar() {
if (_isSet) {
_xifexpression = this.combinedGrammar.get();
} else {
- _xifexpression = (((!this.getOptions().isBacktrackLexer()) && (!this.getOptions().isIgnoreCase())) && (!IterableExtensions.exists(GrammarUtil.allTerminalRules(this.getGrammar()), ((Function1) (TerminalRule it) -> {
- return Boolean.valueOf(this._syntheticTerminalDetector.isSyntheticTerminalRule(it));
- }))));
+ _xifexpression = (((!this.getOptions().isBacktrackLexer()) && (!this.getOptions().isIgnoreCase())) && (!this.hasSyntheticTerminalRule()));
}
return _xifexpression;
}
@@ -159,11 +157,8 @@ protected void doGenerate() {
this.generateProductionParser().writeTo(this.getProjectConfig().getRuntime().getSrcGen());
this.generateAntlrTokenFileProvider().writeTo(this.getProjectConfig().getRuntime().getSrcGen());
this.generateContentAssistParser().writeTo(this.getProjectConfig().getGenericIde().getSrcGen());
- final Function1 _function = (TerminalRule it) -> {
- return Boolean.valueOf(this._syntheticTerminalDetector.isSyntheticTerminalRule(it));
- };
- boolean _exists = IterableExtensions.exists(GrammarUtil.allTerminalRules(this.getGrammar()), _function);
- if (_exists) {
+ boolean _hasSyntheticTerminalRule = this.hasSyntheticTerminalRule();
+ if (_hasSyntheticTerminalRule) {
this.generateProductionTokenSource().writeTo(this.getProjectConfig().getRuntime().getSrc());
this.generateContentAssistTokenSource().writeTo(this.getProjectConfig().getGenericIde().getSrc());
}
@@ -172,6 +167,13 @@ protected void doGenerate() {
this.addUiBindingsAndImports();
}
+ protected boolean hasSyntheticTerminalRule() {
+ final Function1 _function = (TerminalRule it) -> {
+ return Boolean.valueOf(this._syntheticTerminalDetector.isSyntheticTerminalRule(it));
+ };
+ return IterableExtensions.exists(GrammarUtil.allTerminalRules(this.getGrammar()), _function);
+ }
+
public void setLookaheadThreshold(final String lookaheadThreshold) {
this.lookaheadThreshold = Integer.parseInt(lookaheadThreshold);
}
@@ -314,11 +316,8 @@ protected void appendTo(StringConcatenationClient.TargetStringConcatenation _bui
_builder.append("\t");
_builder.newLine();
{
- final Function1 _function = (TerminalRule it) -> {
- return Boolean.valueOf(XtextAntlrGeneratorFragment2.this._syntheticTerminalDetector.isSyntheticTerminalRule(it));
- };
- boolean _exists = IterableExtensions.exists(GrammarUtil.allTerminalRules(XtextAntlrGeneratorFragment2.this.getGrammar()), _function);
- if (_exists) {
+ boolean _hasSyntheticTerminalRule = XtextAntlrGeneratorFragment2.this.hasSyntheticTerminalRule();
+ if (_hasSyntheticTerminalRule) {
_builder.append("\t");
_builder.append("@Override");
_builder.newLine();
@@ -717,11 +716,8 @@ protected void appendTo(StringConcatenationClient.TargetStringConcatenation _bui
_builder.newLine();
_builder.newLine();
{
- final Function1 _function = (TerminalRule it) -> {
- return Boolean.valueOf(XtextAntlrGeneratorFragment2.this._syntheticTerminalDetector.isSyntheticTerminalRule(it));
- };
- boolean _exists = IterableExtensions.exists(GrammarUtil.allTerminalRules(XtextAntlrGeneratorFragment2.this.getGrammar()), _function);
- if (_exists) {
+ boolean _hasSyntheticTerminalRule = XtextAntlrGeneratorFragment2.this.hasSyntheticTerminalRule();
+ if (_hasSyntheticTerminalRule) {
_builder.append("\t");
_builder.append("@Override");
_builder.newLine();
@@ -1180,6 +1176,12 @@ protected void appendTo(StringConcatenationClient.TargetStringConcatenation _bui
TypeReference.typeRef("org.eclipse.xtext.ide.editor.contentassist.antlr.ContentAssistContextFactory"),
TypeReference.typeRef("org.eclipse.xtext.ide.editor.contentassist.antlr.PartialContentAssistContextFactory"));
}
+ boolean _hasSyntheticTerminalRule = this.hasSyntheticTerminalRule();
+ if (_hasSyntheticTerminalRule) {
+ ideBindings.addTypeToType(
+ TypeReference.typeRef("org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider"),
+ TypeReference.typeRef("org.eclipse.xtext.ide.editor.contentassist.IndentationAwareCompletionPrefixProvider"));
+ }
ideBindings.contributeTo(this.getLanguage().getIdeGenModule());
}
@@ -1293,6 +1295,12 @@ protected void appendTo(StringConcatenationClient.TargetStringConcatenation _bui
}
};
final GuiceModuleAccess.BindingFactory uiBindings = _addTypeToType_1.addConfiguredBinding("ContentAssistLexerProvider", _client_3);
+ boolean _hasSyntheticTerminalRule = this.hasSyntheticTerminalRule();
+ if (_hasSyntheticTerminalRule) {
+ uiBindings.addTypeToType(
+ TypeReference.typeRef("org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider"),
+ TypeReference.typeRef("org.eclipse.xtext.ide.editor.contentassist.IndentationAwareCompletionPrefixProvider"));
+ }
uiBindings.contributeTo(this.getLanguage().getEclipsePluginGenModule());
}
From 63efd34885be96683b91ce7b8232fa85de5134af Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Tue, 13 Jun 2017 13:11:47 +0200
Subject: [PATCH 09/17] Regenerated test languages
---
.../AbstractIndentationAwareUiTestLanguageIdeModule.java | 7 +++++++
1 file changed, 7 insertions(+)
diff --git a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/ide/AbstractIndentationAwareUiTestLanguageIdeModule.java b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/ide/AbstractIndentationAwareUiTestLanguageIdeModule.java
index 1e7a80ca41..367c65c22e 100644
--- a/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/ide/AbstractIndentationAwareUiTestLanguageIdeModule.java
+++ b/org.eclipse.xtext.ide.tests/testlang-src-gen/org/eclipse/xtext/ide/tests/testlanguage/ide/AbstractIndentationAwareUiTestLanguageIdeModule.java
@@ -11,9 +11,11 @@
import com.google.inject.name.Names;
import org.eclipse.xtext.ide.DefaultIdeModule;
import org.eclipse.xtext.ide.LexerIdeBindings;
+import org.eclipse.xtext.ide.editor.contentassist.CompletionPrefixProvider;
import org.eclipse.xtext.ide.editor.contentassist.FQNPrefixMatcher;
import org.eclipse.xtext.ide.editor.contentassist.IPrefixMatcher;
import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper;
+import org.eclipse.xtext.ide.editor.contentassist.IndentationAwareCompletionPrefixProvider;
import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper;
import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser;
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
@@ -43,6 +45,11 @@ public Class extends IProposalConflictHelper> bindIProposalConflictHelper() {
return AntlrProposalConflictHelper.class;
}
+ // contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+ public Class extends CompletionPrefixProvider> bindCompletionPrefixProvider() {
+ return IndentationAwareCompletionPrefixProvider.class;
+ }
+
// contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2
public Class extends IPrefixMatcher> bindIPrefixMatcher() {
return FQNPrefixMatcher.class;
From 8f97ceae101c32a021abc791ad89e0bd39af1222 Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Tue, 13 Jun 2017 15:41:53 +0200
Subject: [PATCH 10/17] Attempt to fix the build, ignore Suites
---
org.eclipse.xtext.ide.tests/build.gradle | 12 ++++++++++--
...end => IndentationAwarePartialParsingSuite.xtend} | 2 +-
.../indentation/IndentationTestLanguageSuite.java | 2 +-
...java => IndentationAwarePartialParsingSuite.java} | 2 +-
4 files changed, 13 insertions(+), 5 deletions(-)
rename org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/{IndentationAwarePartialParsingTest.xtend => IndentationAwarePartialParsingSuite.xtend} (95%)
rename org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/{IndentationAwarePartialParsingTest.java => IndentationAwarePartialParsingSuite.java} (95%)
diff --git a/org.eclipse.xtext.ide.tests/build.gradle b/org.eclipse.xtext.ide.tests/build.gradle
index b152ca5554..8664ea2d5f 100644
--- a/org.eclipse.xtext.ide.tests/build.gradle
+++ b/org.eclipse.xtext.ide.tests/build.gradle
@@ -9,16 +9,24 @@ dependencies {
compile "org.eclipse.lsp4j:org.eclipse.lsp4j:$versions.lsp4j"
}
-sourceSets.test.java {
+sourceSets.main.java {
srcDir 'testlang-src'
srcDir 'testlang-src-gen'
+}
+
+sourceSets.test.java {
srcDir 'suites'
}
-sourceSets.test.resources {
+
+sourceSets.main.resources {
srcDir 'testlang-src'
srcDir 'testlang-src-gen'
}
+test {
+ exclude '**/*Suite.class'
+}
+
task generateTestLanguages(type: XtextGeneratorTask) {
workflow = file('testlang-src/org/eclipse/xtext/ide/tests/testlanguage/GenerateTestLanguage.mwe2')
inputs.file 'testlang-src/org/eclipse/xtext/ide/tests/testlanguage/TestLanguage.xtext'
diff --git a/org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingTest.xtend b/org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.xtend
similarity index 95%
rename from org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingTest.xtend
rename to org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.xtend
index 0ad27d7827..d3deb9fabc 100644
--- a/org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingTest.xtend
+++ b/org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.xtend
@@ -19,5 +19,5 @@ import org.junit.runners.Suite.SuiteClasses
@RunWith(XtextSmokeTestRunner)
@ProcessedBy(value = PartialParsingProcessor, processInParallel = true)
@SuiteClasses(CompletionPrefixProviderTest)
-class IndentationAwarePartialParsingTest {
+class IndentationAwarePartialParsingSuite {
}
\ No newline at end of file
diff --git a/org.eclipse.xtext.ide.tests/suites/org/eclipse/xtext/ide/tests/indentation/IndentationTestLanguageSuite.java b/org.eclipse.xtext.ide.tests/suites/org/eclipse/xtext/ide/tests/indentation/IndentationTestLanguageSuite.java
index aa9d465983..bb2a625f09 100644
--- a/org.eclipse.xtext.ide.tests/suites/org/eclipse/xtext/ide/tests/indentation/IndentationTestLanguageSuite.java
+++ b/org.eclipse.xtext.ide.tests/suites/org/eclipse/xtext/ide/tests/indentation/IndentationTestLanguageSuite.java
@@ -18,7 +18,7 @@
@SuiteClasses({
CompletionPrefixProviderTest.class,
IndentationAwareCompletionPrefixProviderTest.class,
- IndentationAwarePartialParsingTest.class
+ IndentationAwarePartialParsingSuite.class
})
public class IndentationTestLanguageSuite {
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingTest.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.java
similarity index 95%
rename from org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingTest.java
rename to org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.java
index 2b97bf010d..d378e4181c 100644
--- a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingTest.java
+++ b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.java
@@ -21,5 +21,5 @@
@ProcessedBy(value = PartialParsingProcessor.class, processInParallel = true)
@Suite.SuiteClasses(CompletionPrefixProviderTest.class)
@SuppressWarnings("all")
-public class IndentationAwarePartialParsingTest {
+public class IndentationAwarePartialParsingSuite {
}
From 21320c6f850f4da37b7ec4cdc16c02507d40b998 Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Tue, 13 Jun 2017 15:53:13 +0200
Subject: [PATCH 11/17] Renamend another test class to *Suite
---
...singTest.xtend => IndentationAwarePartialParsingSuite.xtend} | 2 +-
...arsingTest.java => IndentationAwarePartialParsingSuite.java} | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
rename org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/{IndentationAwarePartialParsingTest.xtend => IndentationAwarePartialParsingSuite.xtend} (95%)
rename org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/{IndentationAwarePartialParsingTest.java => IndentationAwarePartialParsingSuite.java} (95%)
diff --git a/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.xtend b/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.xtend
similarity index 95%
rename from org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.xtend
rename to org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.xtend
index 5cf06bbd39..a51d719afe 100644
--- a/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.xtend
+++ b/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.xtend
@@ -19,5 +19,5 @@ import org.junit.runners.Suite.SuiteClasses
@RunWith(XtextSmokeTestRunner)
@ProcessedBy(value = PartialParsingProcessor, processInParallel = true)
@SuiteClasses(IndentationAwareLanguageTest, NodeModelTest)
-class IndentationAwarePartialParsingTest {
+class IndentationAwarePartialParsingSuite {
}
\ No newline at end of file
diff --git a/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.java b/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.java
similarity index 95%
rename from org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.java
rename to org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.java
index 499066bda5..8d7c281f94 100644
--- a/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.java
+++ b/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.java
@@ -22,5 +22,5 @@
@ProcessedBy(value = PartialParsingProcessor.class, processInParallel = true)
@Suite.SuiteClasses({ IndentationAwareLanguageTest.class, NodeModelTest.class })
@SuppressWarnings("all")
-public class IndentationAwarePartialParsingTest {
+public class IndentationAwarePartialParsingSuite {
}
From efa1c1c8b4408d88ca5cdc20fb081cd73c66f30b Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Tue, 13 Jun 2017 15:54:33 +0200
Subject: [PATCH 12/17] Put test langs into test source set
---
org.eclipse.xtext.ide.tests/build.gradle | 9 +++------
1 file changed, 3 insertions(+), 6 deletions(-)
diff --git a/org.eclipse.xtext.ide.tests/build.gradle b/org.eclipse.xtext.ide.tests/build.gradle
index 8664ea2d5f..60c82bde78 100644
--- a/org.eclipse.xtext.ide.tests/build.gradle
+++ b/org.eclipse.xtext.ide.tests/build.gradle
@@ -9,16 +9,13 @@ dependencies {
compile "org.eclipse.lsp4j:org.eclipse.lsp4j:$versions.lsp4j"
}
-sourceSets.main.java {
- srcDir 'testlang-src'
- srcDir 'testlang-src-gen'
-}
-
sourceSets.test.java {
srcDir 'suites'
+ srcDir 'testlang-src'
+ srcDir 'testlang-src-gen'
}
-sourceSets.main.resources {
+sourceSets.test.resources {
srcDir 'testlang-src'
srcDir 'testlang-src-gen'
}
From 9ba194e7f4d53af282b1c5eb777ddafd7b65a850 Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Tue, 13 Jun 2017 16:45:44 +0200
Subject: [PATCH 13/17] Another attempt to fix all the things (tm)
---
org.eclipse.xtext.ide.tests/build.gradle | 2 +-
.../ide/tests/indentation/IndentationTestLanguageSuite.java | 3 +--
...ingSuite.xtend => IndentationAwarePartialParsingTest.xtend} | 2 +-
...rsingSuite.java => IndentationAwarePartialParsingTest.java} | 2 +-
4 files changed, 4 insertions(+), 5 deletions(-)
rename org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/{IndentationAwarePartialParsingSuite.xtend => IndentationAwarePartialParsingTest.xtend} (95%)
rename org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/{IndentationAwarePartialParsingSuite.java => IndentationAwarePartialParsingTest.java} (95%)
diff --git a/org.eclipse.xtext.ide.tests/build.gradle b/org.eclipse.xtext.ide.tests/build.gradle
index 60c82bde78..008c157a60 100644
--- a/org.eclipse.xtext.ide.tests/build.gradle
+++ b/org.eclipse.xtext.ide.tests/build.gradle
@@ -10,9 +10,9 @@ dependencies {
}
sourceSets.test.java {
- srcDir 'suites'
srcDir 'testlang-src'
srcDir 'testlang-src-gen'
+ srcDir 'suites'
}
sourceSets.test.resources {
diff --git a/org.eclipse.xtext.ide.tests/suites/org/eclipse/xtext/ide/tests/indentation/IndentationTestLanguageSuite.java b/org.eclipse.xtext.ide.tests/suites/org/eclipse/xtext/ide/tests/indentation/IndentationTestLanguageSuite.java
index bb2a625f09..50334ffd28 100644
--- a/org.eclipse.xtext.ide.tests/suites/org/eclipse/xtext/ide/tests/indentation/IndentationTestLanguageSuite.java
+++ b/org.eclipse.xtext.ide.tests/suites/org/eclipse/xtext/ide/tests/indentation/IndentationTestLanguageSuite.java
@@ -17,8 +17,7 @@
@RunWith(Suite.class)
@SuiteClasses({
CompletionPrefixProviderTest.class,
- IndentationAwareCompletionPrefixProviderTest.class,
- IndentationAwarePartialParsingSuite.class
+ IndentationAwareCompletionPrefixProviderTest.class
})
public class IndentationTestLanguageSuite {
diff --git a/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.xtend b/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.xtend
similarity index 95%
rename from org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.xtend
rename to org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.xtend
index a51d719afe..5cf06bbd39 100644
--- a/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.xtend
+++ b/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.xtend
@@ -19,5 +19,5 @@ import org.junit.runners.Suite.SuiteClasses
@RunWith(XtextSmokeTestRunner)
@ProcessedBy(value = PartialParsingProcessor, processInParallel = true)
@SuiteClasses(IndentationAwareLanguageTest, NodeModelTest)
-class IndentationAwarePartialParsingSuite {
+class IndentationAwarePartialParsingTest {
}
\ No newline at end of file
diff --git a/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.java b/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.java
similarity index 95%
rename from org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.java
rename to org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.java
index 8d7c281f94..499066bda5 100644
--- a/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingSuite.java
+++ b/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.java
@@ -22,5 +22,5 @@
@ProcessedBy(value = PartialParsingProcessor.class, processInParallel = true)
@Suite.SuiteClasses({ IndentationAwareLanguageTest.class, NodeModelTest.class })
@SuppressWarnings("all")
-public class IndentationAwarePartialParsingSuite {
+public class IndentationAwarePartialParsingTest {
}
From 14b2f3568401604a587b69037cdfa7e225976e7e Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Tue, 13 Jun 2017 19:32:11 +0200
Subject: [PATCH 14/17] Yet another attempt (tm)
---
.../IndentationAwarePartialParsingSuite.xtend | 23 -----------------
.../IndentationAwarePartialParsingSuite.java | 25 -------------------
...IndentationAwarePartialParsingTests.xtend} | 7 +++++-
.../IndentationAwareLanguageSuite.java | 19 ++++++++++++++
... IndentationAwarePartialParsingTests.java} | 7 ++----
5 files changed, 27 insertions(+), 54 deletions(-)
delete mode 100644 org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.xtend
delete mode 100644 org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.java
rename org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/{IndentationAwarePartialParsingTest.xtend => IndentationAwarePartialParsingTests.xtend} (85%)
create mode 100644 org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwareLanguageSuite.java
rename org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/{IndentationAwarePartialParsingTest.java => IndentationAwarePartialParsingTests.java} (79%)
diff --git a/org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.xtend b/org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.xtend
deleted file mode 100644
index d3deb9fabc..0000000000
--- a/org.eclipse.xtext.ide.tests/src/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.xtend
+++ /dev/null
@@ -1,23 +0,0 @@
-/*******************************************************************************
- * Copyright (c) 2015 itemis AG (http://www.itemis.eu) and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- *******************************************************************************/
-package org.eclipse.xtext.ide.tests.indentation
-
-import org.eclipse.xtext.testing.smoketest.ProcessedBy
-import org.eclipse.xtext.testing.smoketest.XtextSmokeTestRunner
-import org.eclipse.xtext.testing.smoketest.processors.PartialParsingProcessor
-import org.junit.runner.RunWith
-import org.junit.runners.Suite.SuiteClasses
-
-/**
- * @author Sebastian Zarnekow - Initial contribution and API
- */
-@RunWith(XtextSmokeTestRunner)
-@ProcessedBy(value = PartialParsingProcessor, processInParallel = true)
-@SuiteClasses(CompletionPrefixProviderTest)
-class IndentationAwarePartialParsingSuite {
-}
\ No newline at end of file
diff --git a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.java b/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.java
deleted file mode 100644
index d378e4181c..0000000000
--- a/org.eclipse.xtext.ide.tests/xtend-gen/org/eclipse/xtext/ide/tests/indentation/IndentationAwarePartialParsingSuite.java
+++ /dev/null
@@ -1,25 +0,0 @@
-/**
- * Copyright (c) 2015 itemis AG (http://www.itemis.eu) and others.
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the Eclipse Public License v1.0
- * which accompanies this distribution, and is available at
- * http://www.eclipse.org/legal/epl-v10.html
- */
-package org.eclipse.xtext.ide.tests.indentation;
-
-import org.eclipse.xtext.ide.tests.indentation.CompletionPrefixProviderTest;
-import org.eclipse.xtext.testing.smoketest.ProcessedBy;
-import org.eclipse.xtext.testing.smoketest.XtextSmokeTestRunner;
-import org.eclipse.xtext.testing.smoketest.processors.PartialParsingProcessor;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-
-/**
- * @author Sebastian Zarnekow - Initial contribution and API
- */
-@RunWith(XtextSmokeTestRunner.class)
-@ProcessedBy(value = PartialParsingProcessor.class, processInParallel = true)
-@Suite.SuiteClasses(CompletionPrefixProviderTest.class)
-@SuppressWarnings("all")
-public class IndentationAwarePartialParsingSuite {
-}
diff --git a/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.xtend b/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTests.xtend
similarity index 85%
rename from org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.xtend
rename to org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTests.xtend
index 5cf06bbd39..20adbc5153 100644
--- a/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.xtend
+++ b/org.eclipse.xtext.tests/src/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTests.xtend
@@ -12,12 +12,17 @@ import org.eclipse.xtext.testing.smoketest.XtextSmokeTestRunner
import org.eclipse.xtext.testing.smoketest.processors.PartialParsingProcessor
import org.junit.runner.RunWith
import org.junit.runners.Suite.SuiteClasses
+import org.junit.runners.Suite
/**
* @author Sebastian Zarnekow - Initial contribution and API
*/
@RunWith(XtextSmokeTestRunner)
@ProcessedBy(value = PartialParsingProcessor, processInParallel = true)
+class IndentationAwarePartialParsingTests extends IndentationAwareLanguageSuite {
+}
+
+@RunWith(Suite)
@SuiteClasses(IndentationAwareLanguageTest, NodeModelTest)
-class IndentationAwarePartialParsingTest {
+class IndentationAwareLanguageSuite {
}
\ No newline at end of file
diff --git a/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwareLanguageSuite.java b/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwareLanguageSuite.java
new file mode 100644
index 0000000000..9cc68973ec
--- /dev/null
+++ b/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwareLanguageSuite.java
@@ -0,0 +1,19 @@
+/**
+ * Copyright (c) 2015 itemis AG (http://www.itemis.eu) and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.eclipse.xtext.parser.indentation;
+
+import org.eclipse.xtext.parser.indentation.IndentationAwareLanguageTest;
+import org.eclipse.xtext.parser.indentation.NodeModelTest;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+
+@RunWith(Suite.class)
+@Suite.SuiteClasses({ IndentationAwareLanguageTest.class, NodeModelTest.class })
+@SuppressWarnings("all")
+public class IndentationAwareLanguageSuite {
+}
diff --git a/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.java b/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTests.java
similarity index 79%
rename from org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.java
rename to org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTests.java
index 499066bda5..0cba9828c1 100644
--- a/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTest.java
+++ b/org.eclipse.xtext.tests/xtend-gen/org/eclipse/xtext/parser/indentation/IndentationAwarePartialParsingTests.java
@@ -7,20 +7,17 @@
*/
package org.eclipse.xtext.parser.indentation;
-import org.eclipse.xtext.parser.indentation.IndentationAwareLanguageTest;
-import org.eclipse.xtext.parser.indentation.NodeModelTest;
+import org.eclipse.xtext.parser.indentation.IndentationAwareLanguageSuite;
import org.eclipse.xtext.testing.smoketest.ProcessedBy;
import org.eclipse.xtext.testing.smoketest.XtextSmokeTestRunner;
import org.eclipse.xtext.testing.smoketest.processors.PartialParsingProcessor;
import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
/**
* @author Sebastian Zarnekow - Initial contribution and API
*/
@RunWith(XtextSmokeTestRunner.class)
@ProcessedBy(value = PartialParsingProcessor.class, processInParallel = true)
-@Suite.SuiteClasses({ IndentationAwareLanguageTest.class, NodeModelTest.class })
@SuppressWarnings("all")
-public class IndentationAwarePartialParsingTest {
+public class IndentationAwarePartialParsingTests extends IndentationAwareLanguageSuite {
}
From 4a59384b6f1213e9c86c330e934935faaad2f592 Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Mon, 7 Aug 2017 11:13:13 +0200
Subject: [PATCH 15/17] Missing @since tags
---
.../ide/editor/contentassist/antlr/LeafNodeFinder.java | 6 ++++++
.../xtext/parser/antlr/AbstractIndentationTokenSource.java | 6 ++++++
2 files changed, 12 insertions(+)
diff --git a/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/antlr/LeafNodeFinder.java b/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/antlr/LeafNodeFinder.java
index 47974bb8eb..3ff182c6cf 100644
--- a/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/antlr/LeafNodeFinder.java
+++ b/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/antlr/LeafNodeFinder.java
@@ -40,6 +40,9 @@ public ILeafNode caseCompositeNode(ICompositeNode object) {
return null;
}
+ /**
+ * @since 2.13
+ */
protected boolean matchesSearchCriteria(INode object) {
if (leading) {
if (object.getTotalOffset() < offset && object.getTotalLength() + object.getTotalOffset() >= offset) {
@@ -53,6 +56,9 @@ protected boolean matchesSearchCriteria(INode object) {
return object.getTotalOffset() == offset && object.getTotalLength() == 0;
}
+ /**
+ * @since 2.13
+ */
protected ILeafNode searchInChildren(ICompositeNode object) {
Iterator leafNodes = object.getLeafNodes().iterator();
ILeafNode result = null;
diff --git a/org.eclipse.xtext/src/org/eclipse/xtext/parser/antlr/AbstractIndentationTokenSource.java b/org.eclipse.xtext/src/org/eclipse/xtext/parser/antlr/AbstractIndentationTokenSource.java
index 91c992e57e..7797a1890e 100644
--- a/org.eclipse.xtext/src/org/eclipse/xtext/parser/antlr/AbstractIndentationTokenSource.java
+++ b/org.eclipse.xtext/src/org/eclipse/xtext/parser/antlr/AbstractIndentationTokenSource.java
@@ -53,6 +53,9 @@ protected boolean shouldSplitToken(Token token) {
*/
protected abstract boolean shouldSplitTokenImpl(Token token);
+ /**
+ * @since 2.13
+ */
protected void doSplitEofToken(Token token, ITokenAcceptor result) {
if (shouldEmitPendingEndTokens()) {
while(indentationStack.size() > 1) {
@@ -117,6 +120,9 @@ protected void doSplitTokenImpl(Token token, ITokenAcceptor result) {
}
}
+ /**
+ * @since 2.13
+ */
protected void handleRemainingText(Token token, String text, int indentation, ITokenAcceptor result) {
CommonToken trailingToken = createToken((CommonToken) token, text, null, null, nextOffset, null, null);
if (indentation > currentIndentation) {
From 2ae23e7778e6c3ec98f25a99ee5a4794e3b445c4 Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Wed, 30 Aug 2017 10:09:51 +0200
Subject: [PATCH 16/17] Use Character.isWhitespace
---
.../IndentationAwareCompletionPrefixProvider.java | 15 +++++++++------
1 file changed, 9 insertions(+), 6 deletions(-)
diff --git a/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/IndentationAwareCompletionPrefixProvider.java b/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/IndentationAwareCompletionPrefixProvider.java
index e615e7aeac..4110280210 100644
--- a/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/IndentationAwareCompletionPrefixProvider.java
+++ b/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/IndentationAwareCompletionPrefixProvider.java
@@ -40,13 +40,16 @@ public class IndentationAwareCompletionPrefixProvider extends CompletionPrefixPr
*/
@Override
public String getInputToParse(String completeInput, int offset, int completionOffset) {
- for(; offset < completionOffset && offset < completeInput.length(); offset++) {
- char c = completeInput.charAt(offset);
- if (!(c == '\n' || c == '\r' || c == ' ' || c == '\t' || c == '\f')) {
- break;
- }
+ int fixedOffset = includeRightSideWhitespace(completeInput, offset, Math.min(completeInput.length(), completionOffset));
+ return super.getInputToParse(completeInput, fixedOffset, completionOffset);
+ }
+
+ protected int includeRightSideWhitespace(String input, int startOffset, int max) {
+ int result = startOffset;
+ while(result < max && Character.isWhitespace(input.charAt(result))) {
+ result++;
}
- return super.getInputToParse(completeInput, offset, completionOffset);
+ return result;
}
@Override
From 0690bcf72d82cad9341c16065874811ec8e40ba7 Mon Sep 17 00:00:00 2001
From: Sebastian Zarnekow
Date: Wed, 30 Aug 2017 10:11:43 +0200
Subject: [PATCH 17/17] Use better method name
---
.../IndentationAwareCompletionPrefixProvider.java | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/IndentationAwareCompletionPrefixProvider.java b/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/IndentationAwareCompletionPrefixProvider.java
index 4110280210..049beb0a9c 100644
--- a/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/IndentationAwareCompletionPrefixProvider.java
+++ b/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/contentassist/IndentationAwareCompletionPrefixProvider.java
@@ -40,11 +40,11 @@ public class IndentationAwareCompletionPrefixProvider extends CompletionPrefixPr
*/
@Override
public String getInputToParse(String completeInput, int offset, int completionOffset) {
- int fixedOffset = includeRightSideWhitespace(completeInput, offset, Math.min(completeInput.length(), completionOffset));
+ int fixedOffset = getOffsetIncludingWhitespace(completeInput, offset, Math.min(completeInput.length(), completionOffset));
return super.getInputToParse(completeInput, fixedOffset, completionOffset);
}
- protected int includeRightSideWhitespace(String input, int startOffset, int max) {
+ protected int getOffsetIncludingWhitespace(String input, int startOffset, int max) {
int result = startOffset;
while(result < max && Character.isWhitespace(input.charAt(result))) {
result++;