<!DOCTYPE html>
<html>

  <head>
	<meta charset="UTF-8">
	<title>Xtext - Release Notes</title>
	
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
	<meta name="description"
		content="The website of Eclipse Xtext, an open-source framework for development of programming languages and domain-specific languages">
	<meta name="author" content="Sven Efftinge">
	<meta name="author" content="Miro Spoenemann">
	<!--  styles -->
	<!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
	<!--[if lt IE 9]>
	  <script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
	<![endif]-->
	
	<!-- Le fav and touch icons -->
	<link rel="shortcut icon" href="/Xtext/images/favicon.png">
	
	<link href="/Xtext/css/bootstrap.css" rel="stylesheet" type='text/css'>
	<link href="/Xtext/css/bootstrap-responsive.css" rel="stylesheet" type='text/css'>
	<link href="/Xtext/css/shield-responsive.css" rel="stylesheet" type='text/css'>
	<link href='/Xtext/css/fonts.css' rel='stylesheet' type='text/css'>
	<link href="/Xtext/css/prettyPhoto.css" rel="stylesheet" media="screen" type='text/css'>
	<link href="/Xtext/css/prettify.css" type="text/css" rel="stylesheet"/>
	<link href="/Xtext/css/style.css" rel="stylesheet" type='text/css'>
	<!-- cover flow -->
	<link href="/Xtext/css/coverflow.css" rel="stylesheet" type='text/css'>
	<!--[if lt IE 9]>
	  <link href="/css/iebugs.css" rel="stylesheet" type='text/css'>
	<![endif]-->

	<!-- BEGIN Cookie Consent
	<link rel="stylesheet" type="text/css" href="//cdnjs.cloudflare.com/ajax/libs/cookieconsent2/3.0.3/cookieconsent.min.css" />
	<script src="//cdnjs.cloudflare.com/ajax/libs/cookieconsent2/3.0.3/cookieconsent.min.js"></script>
	<script>
	window.addEventListener("load", function(){
	window.cookieconsent.initialise({
		"palette": {
		"popup": {
		  "background": "#000"
		},
		"button": {
		  "background": "#f1d600"
		}
		},
		"theme": "edgeless",
		"type": "opt-in",
		onInitialise: function (status) {
		  var type = this.options.type;
		  var didConsent = this.hasConsented();
		  if (type == 'opt-in' && didConsent) {
		    // TODO: enable cookies
		  }
		  if (type == 'opt-out' && !didConsent) {
		    // TODO: disable cookies
		  }
		},
		onStatusChange: function(status, chosenBefore) {
		  var type = this.options.type;
		  var didConsent = this.hasConsented();
		  if (type == 'opt-in' && didConsent) {
		    // TODO: enable cookies
		  }
		  if (type == 'opt-out' && !didConsent) {
		    // TODO: disable cookies
		  }
		}, 
		onRevokeChoice: function() {
		  var type = this.options.type;
		  if (type == 'opt-in') {
		    // TODO: disable cookies
		  }
		  if (type == 'opt-out') {
		    // TODO: enable cookies
		  }
		},
		"content": {
		"href": "http://www.eclipse.org/legal/privacy.php"
		}
	})});
	</script>
	END Cookie Consent -->
</head>


  <body>
  
    <header class="site-header">

  <!-- Navbar -->
  <div class="navbar navbar-fixed-top">
    <div class="navbar-inner">
      <div class="container">
        <a class="btn btn-navbar" data-toggle="collapse"
          data-target=".nav-collapse"> <span class="icon-bar"></span> <span
          class="icon-bar"></span> <span class="icon-bar"></span>
        </a> <a class="brand" href="/Xtext/index.html"></a>
        <div class="nav-collapse collapse" style="height: 0px;">
          <ul class="nav">
            <!--li ><a href="/Xtext/news.html">News</a></li-->
            <li ><a href="/Xtext/download.html">Download</a></li>
            <li ><a href="/Xtext/documentation/index.html">Documentation</a></li>
            <li ><a href="/Xtext/community.html">Community</a></li>
            <li class="dropdown">
              <a class="dropdown-toggle" data-toggle="dropdown" href="#">Support &amp; Trainings<span class="caret"></span></a>
              <ul class="dropdown-menu">
                <li><a href="https://www.itemis.com/en/xtext/support-and-team/" target="_blank">itemis</a></li>
                <li><a href="https://www.typefox.io/language-engineering/" target="_blank">TypeFox</a></li>
              </ul>
            </li>
            <li ><a href="http://xtend-lang.org">Xtend</a></li>
          </ul>
          <!--div class="nav pull-right">
            <li ><a><iframe src="https://ghbtns.com/github-btn.html?user=eclipse&repo=xtext&type=star&count=true" frameborder="0" scrolling="0" width="170px" height="20px"></iframe></a></li>
          </div-->
        </div>
        <!--/.nav-collapse -->
      </div>
    </div>
  </div>
  <!-- Navbar End -->

</header>


    <div id="page">  
	<div class="inner">
		<div class="container">
			<br/>
				<div> 
					<h3>Table of Contents</h3>
					<ul>
						
							<li><p><a href="#/releasenotes/2022/08/29/version-2-28-0">Xtext 2.28.0 Release Notes &mdash; Aug 29, 2022</a></p>
						
							<li><p><a href="#/releasenotes/2022/05/30/version-2-27-0">Xtext 2.27.0 Release Notes &mdash; May 30, 2022</a></p>
						
							<li><p><a href="#/releasenotes/2022/02/28/version-2-26-0">Xtext 2.26.0 Release Notes &mdash; Feb 28, 2022</a></p>
						
							<li><p><a href="#/releasenotes/2021/03/02/version-2-25-0">Xtext 2.25.0 Release Notes &mdash; Mar 2, 2021</a></p>
						
							<li><p><a href="#/releasenotes/2020/12/01/version-2-24-0">Xtext 2.24.0 Release Notes &mdash; Dec 1, 2020</a></p>
						
							<li><p><a href="#/releasenotes/2020/09/01/version-2-23-0">Xtext 2.23.0 Release Notes &mdash; Sep 1, 2020</a></p>
						
							<li><p><a href="#/releasenotes/2020/06/02/version-2-22-0">Xtext 2.22.0 Release Notes &mdash; Jun 2, 2020</a></p>
						
							<li><p><a href="#/releasenotes/2020/03/03/version-2-21-0">Xtext 2.21.0 Release Notes &mdash; Mar 3, 2020</a></p>
						
							<li><p><a href="#/releasenotes/2019/12/03/version-2-20-0">Xtext 2.20.0 Release Notes &mdash; Dec 3, 2019</a></p>
						
							<li><p><a href="#/releasenotes/2019/09/03/version-2-19-0">Xtext 2.19.0 Release Notes &mdash; Sep 3, 2019</a></p>
						
					</ul>
				</div>
				
				  <hr/>
				  <section id="/releasenotes/2022/08/29/version-2-28-0">
				  	<h1>Xtext 2.28.0 Release Notes<small>&nbsp;&nbsp;Aug 29, 2022</small></h1>
				    <br/>
				    <p>Xtext 2.28.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext">Call to Action: Secure the future maintenance of Xtext</h2>

<p>As you might have recognized, the number of people contributing to Xtext on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="changes-to-orgeclipsextextsdk-feature">Changes to <code>org.eclipse.xtext.sdk</code> feature.</h2>

<p>The <code>org.eclipse.xtext.sdk</code> does no longer package the deprecated <code>org.eclipse.xtext.generator</code> bundle. Please migrate to the new workflow/generator. The old and deprecated generator can still be found in the new <code>org.eclipse.xtext.generator</code> feature.</p>

<h2 id="upgrades">Upgrades</h2>

<ul>
  <li>LSP4J was updated to 0.15.0</li>
  <li>GSON was updated to 2.9.0</li>
</ul>

<h2 id="changes--enhancements">Changes / Enhancements</h2>

<ul>
  <li>LSP Code was optimized and enhanced. We have e.g. done some enhancements to Quickfix API.</li>
  <li>Xtext Supports M2E 2.x</li>
  <li>Xbase based formatters now can be subclassed in Java more easily.</li>
  <li>Better support for needRebuild api in platform.</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>

<p>Christian Dietrich (itemis)<br />
Ruben Porras<br />
Karsten Thoms (karakun)<br />
Frank Benoit (ETAS)<br />
Hannes Wellmann (IILS mbH) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></p>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.28+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.28+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.28&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.28&amp;query_format=advanced&amp;status_whiteboard=v2.28&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2022/05/30/version-2-27-0">
				  	<h1>Xtext 2.27.0 Release Notes<small>&nbsp;&nbsp;May 30, 2022</small></h1>
				    <br/>
				    <p>Xtext 2.27.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext">Call to Action: Secure the future maintenance of Xtext</h2>

<p>As you might have recognized, the number of people contributing to Xtext on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="changes-to-orgeclipsextextsdk-feature">Changes to <code>org.eclipse.xtext.sdk</code> feature.</h2>

<p>The <code>org.eclipse.xtext.sdk</code> does no longer package the deprecated <code>org.eclipse.xtext.generator</code> bundle. Please migrate to the new workflow/generator. The old and deprecated generator can still be found in the new <code>org.eclipse.xtext.generator</code> feature.</p>

<h2 id="upgrades">Upgrades</h2>
<ul>
  <li>Tycho 2.7.3</li>
  <li>Xtext now uses Reload4j 1.2.19</li>
  <li>Gradle 7.4.2 / xtext-gradle-plugin 3.0.2</li>
  <li>ASM 9.3</li>
  <li>MWE(2) to 1.7.0 / 2.13.0</li>
  <li>LSP4j is now on version 0.14.0 / protocol version 3.17.0</li>
</ul>

<h2 id="changes">Changes</h2>
<ul>
  <li>The qualifiers of org.antlr.runtime,javax.xml,org.aopalliance have changed due to (breaking) changes in orbit.</li>
</ul>

<h2 id="enhancements">Enhancements</h2>

<ul>
  <li>Xtext makes now use of the <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=579082">enhanced possibilities</a> for requesting rebuilds in platform. Please test this in your environments and give <a href="https://github.com/eclipse/xtext-eclipse/issues/1820">feedback</a></li>
  <li>The experimental API for Quickfix code actions of the Xtext Language Server Protocol (LSP) implementation has been extended to support textual quickfixes. This comes in addition to the existing support for semantic quickfixes</li>
</ul>

<h2 id="removals">Removals</h2>
<ul>
  <li>Xtext no longer depends on commons lang</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Lorenzo Bettini (Università degli Studi di Firenze)</li>
  <li>Ruben Porras</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Lukas Foerner <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Titouan Vervack (Sigasi)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.27+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.27+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.27&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.27&amp;query_format=advanced&amp;status_whiteboard=v2.27&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2022/02/28/version-2-26-0">
				  	<h1>Xtext 2.26.0 Release Notes<small>&nbsp;&nbsp;Feb 28, 2022</small></h1>
				    <br/>
				    <p>Xtext 2.26.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext">Call to Action: Secure the future maintenance of Xtext</h2>

<p>As you might have recognized, the number of people contributing to Xtext on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="xtext-and-java-17">Xtext and Java 17</h2>

<p>Xtext now supports running on Java 17 with Java 8 and 11 targets. Source and Target 17 are not supported yet and are planned for Xtext 2.27.0. This will also require dropping Java 8 in the next release.</p>

<h2 id="upgrades">Upgrades</h2>

<ul>
  <li>Tycho was updated to 2.6.0</li>
  <li>GSON was updated to 2.8.9</li>
  <li>LSP4J was updated to 0.12.0 / protocol version 3.16.0</li>
  <li>Xtext now uses Guice 5.0.1 and thus the warnings on Java 11+ should be gone.</li>
  <li>ASM was updated to 9.2</li>
  <li>Gradle (in Wizard) is now updated to 7.x and the xtext-gradle-plugin to 3.0.1</li>
  <li>Classgraph is updated to 4.8.137</li>
</ul>

<h2 id="enhancements">Enhancements</h2>

<ul>
  <li>The Xtext LSP implementation has learned folding support.</li>
  <li><a href="https://github.com/eclipse/xtext-maven/issues/139">xtext-maven#139</a> : xtext-maven can now install trace information for DSLs with a derived Java model (for example languages using Xbase).</li>
  <li>Dependencies to Log4j are now less restrictive so that you should be able to use reload4j as drop-in replacement.</li>
</ul>

<h2 id="deprecations">Deprecations</h2>

<ul>
  <li>The already deprecated MergeableManifest classes we marked “for removal”. Make sure you do not longer use them.</li>
  <li>We will drop support for GWT in a future release.</li>
  <li>The next Xtext version will likely no long support Java versions below Java 11.</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>

<p>Christian Dietrich (itemis)<br />
Karsten Thoms (Karakun)<br />
Sebastian Zarnekow (independent)<br />
Ruben Porras  <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /><br />
Dennis Hübner (TypeFox)<br />
Stefan Oehme (independent)<br />
Titouan Vervack (Sigasi)<br />
Edmundo Lopez <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /><br />
Mark Sujew (TypeFox)<br />
Michael Keppler (ETAS) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /><br />
Tamas Miklossy (itemis)<br />
Nico Prediger (itemis)<br />
Heinrich Weichert (AVL DiTEST)<br />
Lawrence Goossens (Sigasi) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /><br />
Oliver Libutzki (independent) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></p>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.26+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.26+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.26&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.26&amp;query_format=advanced&amp;status_whiteboard=v2.26&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2021/03/02/version-2-25-0">
				  	<h1>Xtext 2.25.0 Release Notes<small>&nbsp;&nbsp;Mar 2, 2021</small></h1>
				    <br/>
				    <p>Xtext 2.25.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext">Call to Action: Secure the future maintenance of Xtext</h2>

<p>As you might have recognized, the number of people contributing to Xtext on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext is at risk, at least in the current form and as part of the Eclipse Simrel. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="documentation">Documentation</h2>

<p>The <a href="https://www.eclipse.org/Xtext/documentation/340_lsp_support.html">LSP Support</a> section has been added to the Xtext documentation.</p>

<h2 id="upgrades">Upgrades</h2>

<ul>
  <li>MWE(2) was updated to 2.12.1/1.6.1.</li>
  <li>Xtext now uses Guava 30.1, ASM 9.1 and GSON 2.8.6.</li>
</ul>

<h2 id="bugfixes">Bugfixes</h2>

<ul>
  <li><a href="https://github.com/eclipse/xtext-core/issues/1648">xtext-core#1648</a>: A regression in JUnit 5 API was fixed. It should work well again.</li>
  <li><a href="https://github.com/eclipse/xtext-core/issues/1655">xtext-core#1655</a>: The ANTLR option <code>k</code> in the workflow works now as expected.</li>
  <li><code>XbaseInterpreter</code> now correctly handles the <code>return;</code> statement.</li>
</ul>

<h2 id="enhancements">Enhancements</h2>

<ul>
  <li>The <code>Formatter2</code> is now flagged as API.</li>
  <li>The Java API for <code>Formatter2</code> learned a new, more fancy syntax. e.g. instead of <code>it -&gt; it.noSpace()</code> you now can write <code>this::noSpace</code>.</li>
  <li>The <code>TemplateNewFileWizard</code> and <code>NewFileWizardPrimaryPage</code> API is opened up to allow for easier customization.</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Arne Deutsch (itemis)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Mark Sujew (TypeFox) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Harald Fassler <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Andreas Heiduk <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Lorenzo Addazi (Mälardalen University Sweden)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.25+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.25+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.25&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.25&amp;query_format=advanced&amp;status_whiteboard=v2.25&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2020/12/01/version-2-24-0">
				  	<h1>Xtext 2.24.0 Release Notes<small>&nbsp;&nbsp;Dec 1, 2020</small></h1>
				    <br/>
				    <p>Xtext 2.24.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext">Call to Action: Secure the future maintenance of Xtext</h2>

<p>As you might have recognized, the number of people contributing to Xtext on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext is at risk. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="java-based-api-for-new-formatter">Java based API for new Formatter</h2>

<p>With Xtext 2.24 we introduce a new preliminary <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext/src/org/eclipse/xtext/formatting2/AbstractJavaFormatter.java">API</a> that allows you to implement the Formatter(2) in Java instead of Xtend. With Java 11 and later, you can use local variable type inference and the equivalent of commonly used extensions are available via delegate methods. We encourage you to give it a try and to give feedback.</p>

<h2 id="xtext-generator">Xtext Generator</h2>

<p>The (new) <a href="https://github.com/eclipse/xtext-core/tree/master/org.eclipse.xtext.xtext.generator/src/org/eclipse/xtext/xtext/generator">Xtext Generator</a> is now API.</p>

<h2 id="language-server-protocol">Language Server Protocol</h2>

<p>The Xtext Language Server Protocol (LSP) implementation has now an experimental API for Quickfix code actions (have a look at the <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/editor/quickfix/IQuickFixProvider.java"><code>IQuickFixProvider</code></a> interface and <a href="https://github.com/eclipse/xtext-core/blob/master/org.eclipse.xtext.ide/src/org/eclipse/xtext/ide/server/codeActions/QuickFixCodeActionService.java"><code>QuickFixCodeActionService</code></a> class).</p>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<ul>
  <li>We did a number of performance improvments for editing <code>.xtext</code> files.</li>
  <li>We fixed a flaw in <a href="https://github.com/eclipse/xtext-eclipse/blob/master/org.eclipse.xtext.builder/src/org/eclipse/xtext/builder/ParallelBuilderParticipant.java"><code>ParallelBuilderParticipant</code></a> that may have lead to missing generated files.</li>
  <li>The Validate Action now should behave correctly with Fast, Normal and Expensive Checks.</li>
</ul>

<h2 id="no-xtend">No Xtend</h2>

<p>The Xtext codebase (besides Xtend) is now, with a small number of exceptions in the language generation area, xbase and tests, completely written in Java and thus more proof in a future without Xtend.</p>

<h2 id="upgrades">Upgrades</h2>

<ul>
  <li>Eclipse Platform and JDT Maven dependencies were updated to the 4.17 / Eclipse 2020-09 versions.</li>
  <li>MWE(2) was updated to 2.12.0/1.6.0.</li>
  <li>LSP4J was updated to 0.10.0, but you still can run it with 0.9.0 too.</li>
  <li>Xtext now uses ASM 9.</li>
  <li>Xtext Web uses JQuery 3.5.1.</li>
  <li>We are now Junit 5.7 compatible.</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Arne Deutsch (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Neeraj Bhusare (Zafin)</li>
  <li>Frank Benoit (ETAS)</li>
  <li>George Suaridze (1C-Soft)</li>
  <li>Hannes Niederhausen (itemis)</li>
  <li>Heinrich Weichert (AVL DiTEST) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Srinivas Iyer (Nash Technologies) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Titouan Vervack (Sigasi)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.24+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.24+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.24&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.24&amp;query_format=advanced&amp;status_whiteboard=v2.24&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2020/09/01/version-2-23-0">
				  	<h1>Xtext 2.23.0 Release Notes<small>&nbsp;&nbsp;Sep 1, 2020</small></h1>
				    <br/>
				    <p>Xtext 2.23.0 is a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext">Call to Action: Secure the future maintenance of Xtext</h2>

<p>As you might have recognized, the number of people contributing to Xtext on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext is at risk. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="xtext-xtend-eclipse-and-java-11">Xtext, Xtend, Eclipse, and Java 11</h2>

<p>The Eclipse Platform and Java Development Tools have decided to migrate to Java 11 with the new 2020-09 (4.17) release. Xtext and Xtend depend on these projects both for the integration into Eclipse as well as in the LSP and standalone mode. Xtext 2.23 still works with Java 8, but if you want to work with Xtext in Eclipse 2020-09 (4.17) you have to start your Tycho builds with Java 11 as well as launch your Runtime Eclipse Applications with Java 11.</p>

<p>We decided to follow suit to close a window of opportunity for hard to find bugs. Therefore, the version 2.24 of Xtext and Xtend which is due along with Eclipse 2020-12 will be the first release that depends on Java 11. Please feel encouraged to join the discussion in <a href="https://github.com/eclipse/xtext/issues/1804">https://github.com/eclipse/xtext/issues/1804</a> if you have any concerns, general comments or other suggestions.</p>

<h2 id="ui-testing">UI Testing</h2>

<p>The AbstractCodeMiningTest and the AbstractMultiQuickfixTest base classes have been added to the org.eclipse.xtext.ui.testing package to provide a convenient way to test the code mining and multi-quickfix capabilities. The Xtext example projects and the Xtend code base have been extended by concrete test cases to demonstrate the usage of these framework classes.</p>

<h2 id="junit-5">Junit 5</h2>

<p><code>InjectionExtension</code> now supports the Junit 5 <code>@Nested</code> tests.</p>

<h2 id="core-api">Core API</h2>

<p>A protected method to get at the lazy proxy information of a LazyLinkingResource was added to enable subclasses to work with these.</p>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<h3 id="quickfix-improvements">Quickfix improvements</h3>

<p>Convert a terminal fragment to a terminal rule. It resolves the following errors:</p>

<ul>
  <li>A rule call in the parser rule points to a terminal fragment.</li>
  <li>A hidden token in the grammar definition or a parser rule points to a terminal fragment.</li>
</ul>

<p>Remove illegal hidden token definition. It resolves the following errors:</p>

<ul>
  <li>The hidden-token points to a parser rule, terminal fragment, or an enum rule.</li>
</ul>

<p>Create a new rule definition. It resolves the following errors:</p>

<ul>
  <li>An undefined parser rule is cross-referenced.</li>
  <li>An undefined enum, terminal, or a terminal fragment is cross-referenced.</li>
</ul>

<p>(<a href="https://github.com/eclipse/xtext-eclipse/issues/1448">xtext-eclipse#1448</a>)</p>

<h3 id="eclipse-api">Eclipse API</h3>

<p>The class org.eclipse.xtext.ui.editor.reconciler.TemplatePositionUpdater is now public to be usable for clients.</p>

<h2 id="upgrades">Upgrades</h2>

<ul>
  <li>Eclipse platform dependencies where updated (e.g org.eclipse.core.runtime:3.17.100 to 3.18.0).</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Arne Deutsch (itemis)</li>
  <li>Jan Koehnlein (TypeFox)</li>
  <li>Neeraj Bhusare (Zafin)</li>
  <li>Titouan Vervack (Sigasi)</li>
  <li>Hendrik Eeckhaut (Sigasi)</li>
  <li>Frank Benoit (ETAS) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Aaron R Miller <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Ivan Nieves <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Stéphane Galland (Université de Technologie de Belfort)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.23+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.23+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.23&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.23&amp;query_format=advanced&amp;status_whiteboard=v2.23&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2020/06/02/version-2-22-0">
				  	<h1>Xtext 2.22.0 Release Notes<small>&nbsp;&nbsp;Jun 2, 2020</small></h1>
				    <br/>
				    <p>Xtext 2.22.0 is mainly a maintenance release.</p>

<h2 id="call-to-action-secure-the-future-maintenance-of-xtext">Call to Action: Secure the future maintenance of Xtext</h2>

<p>As you might have recognized, the number of people contributing to Xtext on a regular basis has declined over the past years and so has the number of contributions. At the same time the amount of work for basic maintenance has stayed the same or even increased with the new release cadence of Java and the Eclipse simultaneous release. Briefly: The future maintenance of Xtext is at risk. If you care, please join the discussion in <a href="https://github.com/eclipse/xtext/issues/1721">https://github.com/eclipse/xtext/issues/1721</a>.</p>

<h2 id="documentation">Documentation</h2>

<p>The <a href="https://www.eclipse.org/Xtext/community.html">Xtext community website</a> and the <a href="https://www.eclipse.org/Xtext/documentation/index.html">Xtext documentation website</a> have been updated. New Xtext-based projects have been added, some editor features and the Unit testing / UI testing capabilities have been documented and the embedded code snippets have been updated as well.</p>

<p>We further enhanced the <a href="https://github.com/eclipse/xtext/tree/master/dev-doc">Xtext Developer Documentation</a> to enable the community to easily contribute to Xtext.</p>

<h2 id="code-generation-improvements">Code Generation improvements</h2>
<p>This release contains some fixes to improve the generated code in the <code>src-gen</code> folders. The following files are affected:</p>

<ul>
  <li><code>Internal&lt;dslName&gt;.g</code> file in the <strong>runtime</strong> module - <a href="https://github.com/eclipse/xtext-core/issues/1467">xtext-core#1467</a></li>
  <li><code>Internal&lt;dslName&gt;Parser.java</code> file in the <strong>runtime</strong> module - <a href="https://github.com/eclipse/xtext-core/issues/1467">xtext-core#1467</a></li>
  <li><code>&lt;dslName&gt;GrammarAccess.java</code> file in the <strong>runtime</strong> module - <a href="https://github.com/eclipse/xtext-core/issues/269">xtext-core#269</a></li>
  <li><code>Partial&lt;dslName&gt;ContentAssistParser.java</code> file in the <strong>ide</strong> module - <a href="https://github.com/eclipse/xtext-core/issues/1418">xtext-core#1418</a></li>
</ul>

<p>We encourage you to regenerate your languages with the latest Xtext version. Usually you do not recognize any changes, unless you check-in the <code>src-gen</code> folders in a version control system.</p>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<h2 id="upgrades">Upgrades</h2>

<ul>
  <li>Xtext 2.22 requires ASM 8.0.1 (updated from 7.2.0).</li>
  <li>Maven Tycho was updated to version 1.7.0.</li>
  <li>MWE(2) was updated to 2.11.3/1.5.3.</li>
</ul>

<h2 id="removals">Removals</h2>

<ul>
  <li>Xtext no longer has a direct dependency to ICU4J. If you use ICU4J in your codebase you should also consider to get rid of this dependencies as it will no longer be supported by Eclipse (Platform).</li>
  <li>As announced in the 2.21 Release the deprecated API in the LSP area was removed.</li>
  <li>We also removed the outdated leftovers of IDEA Support in <code>org.eclipse.xtext.xtext.generator</code>.</li>
</ul>

<h2 id="deprecations">Deprecations</h2>

<ul>
  <li><code>IXtext2EcorePostProcessor</code> &amp; <code>XtendXtext2EcorePostProcessor</code> &amp; <code>ProjectAwareXtendXtext2EcorePostProcessor</code> were deprecated as they depend on old Xpand/Xtend(1). As already announced in the <a href="#/releasenotes/2020/03/03/version-2-21-0">2.21 release notes</a> you should avoid depending on the old Xpand based <code>org.eclipse.xtext.generator</code> as well as on Xtend(1) based postprocessing. So if you have an <code>.ext</code> file right next to your <code>.xtext</code> file or subclass the interface it’s about time to switch to a manually maintained Ecore model.</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Neeraj Bhusare (Zafin)</li>
  <li>Arne Deutsch (itemis)</li>
  <li>Jan Koehnlein (TypeFox)</li>
  <li>George Suaridze (1C LLC) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Mathias Rieder (Bachmann)</li>
  <li>Mikael Barbero (Eclipse Foundation)</li>
  <li>Titouan Vervack (Sigasi)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.22+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.22+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.22&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.22&amp;query_format=advanced&amp;status_whiteboard=v2.22&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2020/03/03/version-2-21-0">
				  	<h1>Xtext 2.21.0 Release Notes<small>&nbsp;&nbsp;Mar 3, 2020</small></h1>
				    <br/>
				    <p>Xtext 2.21 is mainly a maintenance release with a focus on internal improvements to enable more people to contribute and only a few new features. The internal usage of Xtend was reduced where it is not beneficial. This improves build performance and lowers the barrier for new contributors. Also all the tests that were failing on Windows only were adapted, such that developing Xtext on Windows machines is now more satisfying.</p>

<h2 id="license-change">License Change</h2>

<p>In compliance with general requirements by the Eclipse Foundation the license for Xtext &amp; Xtend has been changed to <a href="https://www.eclipse.org/legal/epl-2.0/">EPL 2.0</a>.</p>

<h2 id="documentation">Documentation</h2>

<p>The <a href="https://www.eclipse.org/Xtext/community.html">Xtext community website</a> has been updated to list all the cool projects people are building around Xtext/Xtend.<br />
The list is not yet complete, so feel free to contact us if you are also interested in listing your project there.</p>

<p>The documentation about the <a href="https://github.com/eclipse/xtext/blob/master/dev-doc/MaintenanceTasks.md">release process</a> was improved to enable more people to contribute to this process.</p>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<h3 id="skip-create-markers-in-target-folders">Skip create markers in target folders</h3>

<p>Creation of markers in target folders is disabled. This avoids confusing error markers and improves performance at the same time.</p>

<h3 id="avoid-generation-of-dependency-to-xpandold-generator">Avoid generation of dependency to Xpand/old generator</h3>

<p>The wizard to generate projects for existing ecore models does not create a dependency to deprecated Xpand/old generator any more.</p>

<h2 id="xtext-maven-plugin">xtext-maven-plugin</h2>

<h3 id="testgenerate-goal">testGenerate Goal</h3>

<p>The Maven plugin has now two goals, <code>generate</code> and <code>testGenerate</code>. The new <code>testGenerate</code> goal runs during the <code>generate-test-sources</code> phase and uses the test classpath of the Maven project.</p>

<h2 id="lsp">LSP</h2>

<h3 id="multiple-root-folders-per-workspace">Multiple root folders per workspace</h3>

<p>Xtext based languages now allow a workspace to be composed of multiple root folders.</p>

<h2 id="upgrades">Upgrades</h2>

<ul>
  <li>MWE(2) was updated to 2.11.2 / 1.5.2.</li>
  <li>Xtext 2.21 now requires EMF 2.20 as minimal required version.</li>
  <li>LSP4J is now on version 0.9.0 / Language Server Protocol version 3.15.</li>
  <li>Maven Tycho was updated to version 1.6.0.</li>
  <li>JUnit was updated to version 5.6.</li>
</ul>

<h2 id="deprecations">Deprecations</h2>

<ul>
  <li>In <code>org.eclipse.xtext.ide</code> many of the LSP Services were changed in the protocol to use service specific parameters instead of <code>TextDocumentPositionParams</code>. We adapted the services to use the new parameter classes and marked the old ones as deprecated and to be removed with Xtext 2.22. If you have custom subclasses of the affected services please adapt your implementations. This also holds true for deprecations in lsp services that we marked as deprecated in earlier releases.</li>
  <li>We again encourage you to get rid of the old generator as we might have to remove it in 2020-06 / Xtext 2.22 - see/join <a href="https://github.com/eclipse/xtext/issues/1669">Xtext Issue #1669</a>.</li>
</ul>

<h2 id="credits">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Karsten Thoms (Karakun)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Arne Deutsch (itemis)</li>
  <li>Marcus Mews (NumberFour)</li>
  <li>Lorenzo Bettini (Università degli Studi di Firenze)</li>
  <li>Sven Efftinge (TypeFox)</li>
  <li>Jan Rosczak (Hapag-Lloyd)</li>
  <li>Jan Koehnlein (TypeFox)</li>
  <li>Robert Lewis <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Ryan Dunn <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Mathias Rieder (Bachmann)</li>
  <li>Hannes Niederhausen (itemis) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>David Medina (Sigasi) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. Almost 60 issues and 320 pull requests have made it into this release. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.21+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.21+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.21&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.21&amp;query_format=advanced&amp;status_whiteboard=v2.21&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2019/12/03/version-2-20-0">
				  	<h1>Xtext 2.20.0 Release Notes<small>&nbsp;&nbsp;Dec 3, 2019</small></h1>
				    <br/>
				    <p>Xtext 2.20.0 is mainly a maintenance release.</p>

<h2 id="eclipse-integration">Eclipse Integration</h2>

<h3 id="egit-minimal-version">EGit minimal version</h3>

<p>Xtext requires to use EGit 4.1 or newer now. We have removed a workaround that prevented an endless build loop caused by EGit <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=474003">Bug#474003</a>. Since we expect that no clients are still using Xtext &gt;= 2.20 together with the ancient EGit version, we felt safe to finally remove this workaround.</p>

<h3 id="new-project-wizard--new-file-wizard-improvements">New Project Wizard / New File Wizard improvements</h3>

<p>The <code>New Project Wizard</code> / <code>New File Wizard</code> generator fragments have been extended by the <code>generateToolbarButton</code> option. Setting this option to <code>true</code> adds new project wizard / new file wizard buttons to the toolbar. Furthermore, the New Project Wizard templates provide an API to<br />
register images that can be used in the template descriptions. All these wizard improvements are demonstrated by the Statemachine example shipped by the Xtext framework.</p>

<h2 id="xtext-web">Xtext-Web</h2>

<p>The <code>Xtext-Web Entities Example</code> provides improved validator and formatter capabilities, such as validating the entity, property and operation names, validating the uniquness of the property/operation definitions as well as properly formatting the defined packages, entities, properties and operations elements.</p>

<h2 id="upgrades">Upgrades</h2>

<ul>
  <li>The Eclipse Modeling Workflow Engine (MWE2) was updated to version 2.11.1.</li>
  <li>LSP4J is now on version 0.8.1.</li>
  <li>Maven Tycho was updated to version 1.5.1.</li>
  <li>Gradle to version 5.6.x (Should also work with Gradle 6.0.x which we will ship with Xtext 2.21).</li>
  <li>grgit Gradle Plugin 4.0.0</li>
</ul>

<h2 id="xtend">Xtend</h2>

<p>A word on Xtend. Back in 2013 Xtend was the “Java 10 of today” even before Java 8 was out. Meanwhile Java Release cadence has speeded up and many of Xtends features can be achieved with pure Java, too. There is still some areas where Xtend is particularly advanced like Code generation, Unit tests and lambda heavy APIs like JvmModelInferrer and Formatter. For other tasks there is no need to use Xtend. Also the resources we have no longer allow us to keep the head start against Java. And learning Xtend still is a burden for new Xtext users. To reflect this changed situation we have decided to make Java the default in the wizard again (except e.g. the Generator and a few other APIs). You can still decide if you want Java or Xtend in the workflow.</p>

<h2 id="deprecations">Deprecations</h2>

<h3 id="old-generator">Old Generator</h3>

<p>With Xtext 2.9 we changed the way Xtext languages are generated to a new generator infrastructure/workflow (<code>org.eclipse.xtext.xtext.generator</code>). Until now we still kept the support for the old (Xpand based) workflows and generator (<code>org.eclipse.xtext.generator</code>). We also allowed to use old generator fragments in new workflows through <code>org.eclipse.xtext.generator.adapter.FragmentAdapter</code>. As we want to stop using old Xpand in Xtext we will drop this support in a future Xtext release. We strongly recommend you to migrate to the new workflow and to get rid of the usages of <code>FragmentAdapter</code>.</p>

<h3 id="xtend1-based-ixtext2ecorepostprocessor">Xtend(1) based IXtext2EcorePostProcessor</h3>

<p>Xtext has basically two methods to work with metamodels. The first on is to infer the metamodel from the Grammar. The second one is to maintain it manually and import it in Xtext. In the past we had actually a third option too: To hook into the inference with a <code>IXtext2EcorePostProcessor</code> written in old Xtend(1). We plan to drop this feature in the future and recommend you to switch to a manually maintained metamodel.</p>

<h2 id="credits">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Karsten Thoms (itemis)</li>
  <li>Sebastian Zarnekow (independent)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>D. Gabriel (Bachmann) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Jan Köhnlein (TypeFox)</li>
  <li>Arne Deutsch (itemis)</li>
  <li>Mathias Rieder <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Elena Rogleva <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Mark Christiaens (Sigasi)</li>
  <li>Simeon Andreev (Advantest) <img src="https://img.shields.io/badge/-first%20time%20contributor-green.svg" alt="" /></li>
  <li>Stéphane Galland (Université de Technologie de Belfort)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. Almost 60 issues and 320 pull requests have made it into this release. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.20+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.20+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.20&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.20&amp;query_format=advanced&amp;status_whiteboard=v2.20&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
				  <hr/>
				  <section id="/releasenotes/2019/09/03/version-2-19-0">
				  	<h1>Xtext 2.19.0 Release Notes<small>&nbsp;&nbsp;Sep 3, 2019</small></h1>
				    <br/>
				    <p>Xtext 2.19.0 is mainly a maintenance release.</p>

<h2 id="lsp-integration">LSP Integration</h2>

<p>Xtext 2.19 now uses LSP4J version 0.8.0 / Language Server Protocol version 3.14.0. This allows you to consume Xtext Language Servers through WebSocket.</p>

<h2 id="classgraph">Classgraph</h2>

<p>We use Classgraph to scan the classpath. This allows us to provide Standlone Content Assist proposals (LSP/WEB) not only when the application runs with Java 8 but with Java 11, too.</p>

<h2 id="upgrades">Upgrades</h2>

<p>Xtext now uses Guava 27.1.0. The new version will be picked up automatically if you make use of the Xtext BOM or consume Xtext from its P2 repository.<br />
The MWE(2) version was updated to 2.11.</p>

<h2 id="gradle">Gradle</h2>

<p>We made building Xtext projects and Xtext itself Gradle 6.0 ready and thus future-proof.</p>

<h2 id="maven-tycho">Maven Tycho</h2>

<p>For our integration of Eclipse Tycho based builds with Eclipse Orbit we now make use of the new Orbit Simrel Alias <a href="https://download.eclipse.org/tools/orbit/downloads/2019-09">https://download.eclipse.org/tools/orbit/downloads/2019-09</a> instead of our own solution <a href="https://download.eclipse.org/modeling/tmf/xtext/updates/orbit/2019-09">https://download.eclipse.org/modeling/tmf/xtext/updates/orbit/2019-09</a>.</p>

<h2 id="infrastructure">Infrastructure</h2>

<p>Xtend now is built on the new Kubernetes based CBI infrastructure <a href="https://wiki.eclipse.org/CBI/Jenkins_Migration_FAQ">JIRO</a>.</p>

<h2 id="more-upgrades">More Upgrades</h2>

<p>Xtext always follows the latest releases of the software it relies on. The following software upgrades have been considered for this release:</p>

<ul>
  <li>Latest supported Eclipse Platform 4.13 (a.k.a. 2019-09)</li>
  <li>Eclipse MWE 2.11</li>
  <li>Guava 27.1</li>
  <li>LSP4J 0.8</li>
  <li>jquery 3.4.1</li>
  <li>node 10.16.0</li>
  <li>Maven Plugins:
    <ul>
      <li>maven-compiler-plugin 3.8.1</li>
      <li>maven-source-plugin 3.1.0</li>
    </ul>
  </li>
  <li>Gradle 5.5</li>
  <li>Gradle Plugins:
    <ul>
      <li>com.github.johnrengelman.shadow 5.1.0</li>
      <li>io.spring.dependency-management 1.0.8.RELEASE</li>
      <li>de.esoco.gwt 1.0.9</li>
      <li>org.ajoberstar.grgit 3.1.1</li>
    </ul>
  </li>
</ul>

<h2 id="deprecations">Deprecations</h2>

<h3 id="generator-fragments">Generator Fragments</h3>

<p>The generator fragments</p>

<ul>
  <li><code>org.eclipse.xtext.generator.adapter.FragmentAdapter</code></li>
  <li><code>org.eclipse.xtext.generator.parser.antlr.XtextAntlrGeneratorComparisonFragment</code></li>
</ul>

<p>have been marked deprecated. They are in the already deprecated bundle <code>org.eclipse.xtext.generator</code>. There is currently no replacement for this fragment in the new <code>org.eclipse.xtext.xtext.generator</code> bundle.</p>

<h2 id="credits">Credits</h2>

<p>The Xtext project is thankful for the dedication of each committer and contributor. This release has been made possible by the following persons (in order of the number of contributed commits to this release to <a href="https://github.com/eclipse/xtext#repositories">all repositories</a> except <a href="https://github.com/eclipse/xtext-xtend">xtext-xtend</a>):</p>

<ul>
  <li>Christian Dietrich (itemis)</li>
  <li>Karsten Thoms (itemis)</li>
  <li>Nico Prediger (itemis)</li>
  <li>Sebastian Zarnekow (itemis)</li>
  <li>Tamas Miklossy (itemis)</li>
  <li>Lorenzo Addazi (Mälardalen University Sweden)</li>
  <li>Marcus Mews (NumberFour)</li>
</ul>

<h2 id="fixed-issues">Fixed Issues</h2>

<p>As in every release cycle we were eagerly hunting down bugs, and reviewed and integrated plenty of contributions. 85 issues and 330 pull requests have made it into this release. For further details please refer to the following lists:</p>

<ul>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Aissue+milestone%3ARelease_2.19+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Fixed GitHub issues</a></p>
  </li>
  <li>
    <p><a href="https://github.com/search?utf8=%E2%9C%93&amp;q=is%3Apr+milestone%3ARelease_2.19+is%3Aclosed+repo%3Aeclipse%2Fxtext+repo%3Aeclipse%2Fxtext-core+repo%3Aeclipse%2Fxtext-lib+repo%3Aeclipse%2Fxtext-extras+repo%3Aeclipse%2Fxtext-eclipse+repo%3Aeclipse%2Fxtext-idea+repo%3Aeclipse%2Fxtext-web+repo%3Aeclipse%2Fxtext-maven+repo%3Aeclipse%2Fxtext-xtend&amp;type=Issues&amp;ref=searchresults">Closed Pull Requests</a></p>
  </li>
  <li>
    <p><a href="https://bugs.eclipse.org/bugs/buglist.cgi?bug_status=RESOLVED&amp;bug_status=VERIFIED&amp;bug_status=CLOSED&amp;classification=Modeling&amp;classification=Tools&amp;columnlist=product%2Ccomponent%2Cassigned_to%2Cbug_status%2Cresolution%2Cshort_desc%2Cchangeddate%2Ckeywords&amp;f0=OP&amp;f1=OP&amp;f3=CP&amp;f4=CP&amp;known_name=Xtext%202.19&amp;list_id=16618269&amp;product=TMF&amp;product=Xtend&amp;query_based_on=Xtext%202.19&amp;query_format=advanced&amp;status_whiteboard=v2.19&amp;status_whiteboard_type=allwordssubstr">Fixed Eclipse Bugzilla tickets</a></p>
  </li>
</ul>

				  </section>
				
			
		</div>
  	</div>
</div>
    
    <footer class="site-footer">
  <div id="extra">
    <div class="inner">
      <div class="container">
        <div class="row">
          <div class="span6">
            <h3 class="footer-links-header">Quick Links</h3>
            <ul class="footer-links clearfix">
              <li><a href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a></li>
              <li><a href="http://www.eclipse.org/legal/termsofuse.php">Terms of Use</a></li>
              <li><a href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a></li>
              <li><a href="http://www.eclipse.org/legal/">Legal</a></li>
            </ul>
            <ul class="footer-links clearfix">
              <li><a href="http://www.eclipse.org">Eclipse Home</a></li>
              <li><a href="http://marketplace.eclipse.org/">Market Place</a></li>
              <li><a href="http://www.planeteclipse.org/">Eclipse Planet</a></li>
              <li><a href="https://www.eclipse.org/forums/index.php/f/27/">Xtext Forum</a></li>
            </ul>
          </div>
          <div class="span6">
            <!-- Social Media Links -->
            <h3 class="footer-links-header"">Social Media</h3>
            <ul class="footer-links clearfix">
              <li>
                <a href="https://twitter.com/xtext"><img src="/Xtext/images/Twitter-bird-darkgray.png" class="img-responsive" style="margin-right: 5px;height: 1em;" alt="Twitter icon">@xtext on Twitter</a>
              </li>
            </ul>
          </div>
        </div>
      </div>
    </div>
  </div>
  <a href="#" class="scrollup fadeOutRight animated" style="display: none;">ScrollUp</a>
  <!-- Le javascript
      ================================================== -->
  <!-- Placed at the end of the document so the pages load faster -->
  
  <script src="/Xtext/js/jquery-1.11.3.min.js"></script>
  <script src="/Xtext/js/bootstrap.min.js"></script>
  <script src="/Xtext/js/jquery.easing.1.3.js" type="text/javascript"></script>
  <script src="/Xtext/js/jquery.prettyPhoto.js" type="text/javascript"></script>
  <script src="/Xtext/js/prettify.js" type="text/javascript"></script>
  <script src="/Xtext/js/lang-xtend.js" type="text/javascript"></script>
  <script src="/Xtext/js/lang-common.js" type="text/javascript"></script>
  <script src="/Xtext/js/custom.js" type="text/javascript"></script>
  <!--script src="https://apis.google.com/js/platform.js" async defer></script-->
  <!--script type="text/javascript">
    var _gaq = _gaq || [];  
      _gaq.push([ '_setAccount', 'UA-2429174-3' ]);
    _gaq.push([ '_trackPageview' ]);
    (function() {
      var ga = document.createElement('script');
      ga.type = 'text/javascript';
      ga.async = true;
      ga.src = ('https:' == document.location.protocol ? 'https://ssl'
          : 'http://www')
          + '.google-analytics.com/ga.js';
      var s = document.getElementsByTagName('script')[0];
      s.parentNode.insertBefore(ga, s);
    })();
  </script-->
  <script src="/Xtext/js/coverflow.min.js" type="text/javascript"></script>
  <script>
      $(function() {
        $('#coverflow').coverflow({
          active : 1,
          visibleAside: 2,
          overlap : 0.5,
          scale : 0.9,
          angle : 20,
          trigger : {
            "itemfocus" : true,
            "swipe" : true,
            "mousewheel" : false
          }
        });
        $('#coverflow :hidden').toggle();
        $(window).resize(function() {
          $('#coverflow').coverflow();
        });
      });

  </script>
</footer>


  </body>

</html>
