Bug 576045 - Leverage option of highlighting 'restricted identifiers'
for OT/J scoped keywords
- includes changes in parser etc. to record more positions (both ASTs)
diff --git a/org.eclipse.jdt.core/.settings/.api_filters b/org.eclipse.jdt.core/.settings/.api_filters
index 57a8701..91eb28a 100644
--- a/org.eclipse.jdt.core/.settings/.api_filters
+++ b/org.eclipse.jdt.core/.settings/.api_filters
@@ -8,67 +8,6 @@
</message_arguments>
</filter>
</resource>
- <resource path="compiler/org/eclipse/objectteams/otdt/core/compiler/IOTConstants.java" type="org.eclipse.objectteams.otdt.core.compiler.IOTConstants">
- <filter comment="cleanup constants to avoid near-term conflict with JDT" id="388194388">
- <message_arguments>
- <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
- <message_argument value="T_OrgObjectTeamsIBoundBase"/>
- <message_argument value="102"/>
- </message_arguments>
- </filter>
- <filter comment="cleanup constants to avoid near-term conflict with JDT" id="388194388">
- <message_arguments>
- <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
- <message_argument value="T_OrgObjectTeamsIBoundBase2"/>
- <message_argument value="104"/>
- </message_arguments>
- </filter>
- <filter comment="cleanup constants to avoid near-term conflict with JDT" id="388194388">
- <message_arguments>
- <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
- <message_argument value="T_OrgObjectTeamsITeam"/>
- <message_argument value="100"/>
- </message_arguments>
- </filter>
- <filter comment="cleanup constants to avoid near-term conflict with JDT" id="388194388">
- <message_arguments>
- <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
- <message_argument value="T_OrgObjectTeamsInstantiation"/>
- <message_argument value="103"/>
- </message_arguments>
- </filter>
- <filter comment="cleanup constants to avoid near-term conflict with JDT" id="388194388">
- <message_arguments>
- <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
- <message_argument value="T_OrgObjectTeamsTeam"/>
- <message_argument value="101"/>
- </message_arguments>
- </filter>
- <filter comment="constant name was corrected" id="405864542">
- <message_arguments>
- <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
- <message_argument value="TEAM_ICONFINED"/>
- </message_arguments>
- </filter>
- <filter comment="name corrected" id="1211105284">
- <message_arguments>
- <message_argument value="ITEAM_ICONFINED"/>
- </message_arguments>
- </filter>
- </resource>
- <resource path="compiler/org/eclipse/objectteams/otdt/core/compiler/OTNameUtils.java" type="org.eclipse.objectteams.otdt.core.compiler.OTNameUtils">
- <filter comment="method signature was improved" id="338792546">
- <message_arguments>
- <message_argument value="org.eclipse.objectteams.otdt.core.compiler.OTNameUtils"/>
- <message_argument value="isPredefinedConfined(char[][])"/>
- </message_arguments>
- </filter>
- <filter comment="method signature was improved" id="1143996420">
- <message_arguments>
- <message_argument value="isPredefinedConfined(ReferenceBinding)"/>
- </message_arguments>
- </filter>
- </resource>
<resource path="compiler/org/eclipse/jdt/core/compiler/IProblem.java" type="org.eclipse.jdt.core.compiler.IProblem">
<filter id="388194388">
<message_arguments>
@@ -211,6 +150,67 @@
</message_arguments>
</filter>
</resource>
+ <resource path="compiler/org/eclipse/objectteams/otdt/core/compiler/IOTConstants.java" type="org.eclipse.objectteams.otdt.core.compiler.IOTConstants">
+ <filter comment="cleanup constants to avoid near-term conflict with JDT" id="388194388">
+ <message_arguments>
+ <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
+ <message_argument value="T_OrgObjectTeamsIBoundBase"/>
+ <message_argument value="102"/>
+ </message_arguments>
+ </filter>
+ <filter comment="cleanup constants to avoid near-term conflict with JDT" id="388194388">
+ <message_arguments>
+ <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
+ <message_argument value="T_OrgObjectTeamsIBoundBase2"/>
+ <message_argument value="104"/>
+ </message_arguments>
+ </filter>
+ <filter comment="cleanup constants to avoid near-term conflict with JDT" id="388194388">
+ <message_arguments>
+ <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
+ <message_argument value="T_OrgObjectTeamsITeam"/>
+ <message_argument value="100"/>
+ </message_arguments>
+ </filter>
+ <filter comment="cleanup constants to avoid near-term conflict with JDT" id="388194388">
+ <message_arguments>
+ <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
+ <message_argument value="T_OrgObjectTeamsInstantiation"/>
+ <message_argument value="103"/>
+ </message_arguments>
+ </filter>
+ <filter comment="cleanup constants to avoid near-term conflict with JDT" id="388194388">
+ <message_arguments>
+ <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
+ <message_argument value="T_OrgObjectTeamsTeam"/>
+ <message_argument value="101"/>
+ </message_arguments>
+ </filter>
+ <filter comment="constant name was corrected" id="405864542">
+ <message_arguments>
+ <message_argument value="org.eclipse.objectteams.otdt.core.compiler.IOTConstants"/>
+ <message_argument value="TEAM_ICONFINED"/>
+ </message_arguments>
+ </filter>
+ <filter comment="name corrected" id="1211105284">
+ <message_arguments>
+ <message_argument value="ITEAM_ICONFINED"/>
+ </message_arguments>
+ </filter>
+ </resource>
+ <resource path="compiler/org/eclipse/objectteams/otdt/core/compiler/OTNameUtils.java" type="org.eclipse.objectteams.otdt.core.compiler.OTNameUtils">
+ <filter comment="method signature was improved" id="338792546">
+ <message_arguments>
+ <message_argument value="org.eclipse.objectteams.otdt.core.compiler.OTNameUtils"/>
+ <message_argument value="isPredefinedConfined(char[][])"/>
+ </message_arguments>
+ </filter>
+ <filter comment="method signature was improved" id="1143996420">
+ <message_arguments>
+ <message_argument value="isPredefinedConfined(ReferenceBinding)"/>
+ </message_arguments>
+ </filter>
+ </resource>
<resource path="dom/org/eclipse/jdt/core/dom/AST.java" type="org.eclipse.jdt.core.dom.AST">
<filter id="388194388">
<message_arguments>
@@ -524,6 +524,14 @@
</message_arguments>
</filter>
</resource>
+ <resource path="dom/org/eclipse/jdt/core/dom/GuardPredicateDeclaration.java" type="org.eclipse.jdt.core.dom.GuardPredicateDeclaration">
+ <filter comment="Extending ASTNode is OK inside this plugin" id="576778288">
+ <message_arguments>
+ <message_argument value="ASTNode"/>
+ <message_argument value="GuardPredicateDeclaration"/>
+ </message_arguments>
+ </filter>
+ </resource>
<resource path="dom/org/eclipse/jdt/core/dom/ImportDeclaration.java" type="org.eclipse.jdt.core.dom.ImportDeclaration">
<filter id="576778288">
<message_arguments>
@@ -554,6 +562,14 @@
</message_arguments>
</filter>
</resource>
+ <resource path="dom/org/eclipse/jdt/core/dom/MethodBindingOperator.java" type="org.eclipse.jdt.core.dom.MethodBindingOperator">
+ <filter comment="Extending ASTNode is OK inside this plugin" id="576778288">
+ <message_arguments>
+ <message_argument value="ASTNode"/>
+ <message_argument value="MethodBindingOperator"/>
+ </message_arguments>
+ </filter>
+ </resource>
<resource path="dom/org/eclipse/jdt/core/dom/MethodRef.java" type="org.eclipse.jdt.core.dom.MethodRef">
<filter id="576725006">
<message_arguments>
@@ -658,14 +674,6 @@
</message_arguments>
</filter>
</resource>
- <resource path="dom/org/eclipse/jdt/core/dom/RoleTypeDeclaration.java" type="org.eclipse.jdt.core.dom.RoleTypeDeclaration">
- <filter comment="copied addition from JDT" id="336658481">
- <message_arguments>
- <message_argument value="org.eclipse.jdt.core.dom.RoleTypeDeclaration"/>
- <message_argument value="PERMITS_TYPES_PROPERTY"/>
- </message_arguments>
- </filter>
- </resource>
<resource path="dom/org/eclipse/jdt/core/dom/SimpleName.java" type="org.eclipse.jdt.core.dom.SimpleName">
<filter id="576778288">
<message_arguments>
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ImportReference.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ImportReference.java
index 29e6bf1..90200be 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ImportReference.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/ImportReference.java
@@ -44,7 +44,9 @@
// star end position
public int trailingStarPosition;
-//{ObjectTeams: new queries:
+//{ObjectTeams:
+ public int baseModifierPosition;
+// new queries:
public boolean isTeam() {
return (this.modifiers & ExtraCompilerModifiers.AccTeam) != 0;
}
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java
index fe35851..b5616d4 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/ast/TypeDeclaration.java
@@ -183,6 +183,7 @@
public AbstractMethodMappingDeclaration[] callinCallouts;
public PrecedenceDeclaration[] precedences;
public TypeReference baseclass;
+ public int playedByStart;
// (stored by Parser.consumePredicate(), copied to methods from Parser.dispatchDeclarationInto())
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
index 7bf8c9d..6cb5e97 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/jdt/internal/compiler/parser/Parser.java
@@ -3530,6 +3530,7 @@
typeDecl.bits |= (baseclass.bits & ASTNode.HasTypeAnnotations);
typeDecl.baseclass = baseclass;
typeDecl.baseclass.setBaseclassDecapsulation(DecapsulationState.ALLOWED);
+ typeDecl.playedByStart = this.intStack[this.intPtr--];
typeDecl.bodyStart = typeDecl.baseclass.sourceEnd + 1;
// recovery
if (this.currentElement != null) {
@@ -11758,7 +11759,9 @@
impt.declarationEnd = impt.declarationSourceEnd;
//this.endPosition is just before the ;
//OT/J: consume start and end position of base:
- this.intPtr-=2;
+ impt.baseModifierPosition = this.intStack[this.intPtr--];
+ this.intPtr-=1;
+//
impt.declarationSourceStart = this.intStack[this.intPtr--];
//OT/J never an error (unlike static):
@@ -12827,6 +12830,7 @@
//{ObjectTeams: new constructs storing startPosition, too.
case TokenNamewithin:
case TokenNameprecedence:
+ case TokenNameplayedBy :
// SH}
case TokenNamemodule:
case TokenNamerequires:
@@ -12952,7 +12956,6 @@
// case TokenNameinstanceof :
//{ObjectTeams: new tokens without special treatment:
// case TokenNameas :
- // case TokenNameplayedBy :
// case TokenNameprecedence :
// case TokenNamereadonly :
// case TokenNamewith :
diff --git a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/ReplaceSingleNameVisitor.java b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/ReplaceSingleNameVisitor.java
index 0e17d95..00d6d92 100644
--- a/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/ReplaceSingleNameVisitor.java
+++ b/org.eclipse.jdt.core/compiler/org/eclipse/objectteams/otdt/internal/core/compiler/statemachine/transformer/ReplaceSingleNameVisitor.java
@@ -63,11 +63,11 @@
*/
public static boolean performReplacement(ASTNode node, BlockScope scope, char[] oldName, final char[] newName)
{
- final int start = node.sourceStart;
+ final long pos = (((long) node.sourceStart) << 32) + node.sourceEnd;
IExpressionProvider provider = new IExpressionProvider() {
@Override
public Expression newExpression() {
- return new SingleNameReference(newName, start);
+ return new SingleNameReference(newName, pos);
}
};
ReplaceSingleNameVisitor replaceSingleNameVisitor = new ReplaceSingleNameVisitor(oldName, provider);
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
index 5752489..5164ab9 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ASTConverter.java
@@ -3897,6 +3897,7 @@
//{ObjectTeams: base imports:
} else if (modifiers == ExtraCompilerModifiers.AccBase) {
importDeclaration.setBase(true);
+ importDeclaration.setBaseModifierPosition(importReference.baseModifierPosition);
// SH}
} else {
importDeclaration.setFlags(importDeclaration.getFlags() | ASTNode.MALFORMED);
@@ -7076,6 +7077,7 @@
private RoleTypeDeclaration buildRoleTypeDeclaration(org.eclipse.jdt.internal.compiler.ast.TypeDeclaration typeDeclaration)
{
RoleTypeDeclaration roleTypeDecl = this.ast.newRoleTypeDeclaration();
+ roleTypeDecl.setPlayedByPosition(typeDeclaration.playedByStart);
char[] oldSource = null;
try {
if (typeDeclaration.isRoleFile()) {
@@ -7221,6 +7223,7 @@
private GuardPredicateDeclaration convertGuardPredicate(org.eclipse.objectteams.otdt.internal.core.compiler.ast.GuardPredicateDeclaration guard) {
GuardPredicateDeclaration newGuard = this.ast.newGuardPredicateDeclaration();
newGuard.setSourceRange(guard.declarationSourceStart, guard.declarationSourceEnd - guard.declarationSourceStart + 1);
+ newGuard.setWhenPosition(guard.sourceStart);
if (guard.hasParsedStatements) {
org.eclipse.jdt.internal.compiler.ast.ReturnStatement returnStat = guard.returnStatement;
newGuard.setExpression(convert(returnStat.expression));
@@ -7448,7 +7451,7 @@
// convert methods for OT-specific internal types CallinMappingDeclaration
// and CalloutMappingDeclaration
- public CallinMappingDeclaration convert(
+ public AbstractMethodMappingDeclaration convert(
org.eclipse.objectteams.otdt.internal.core.compiler.ast.CallinMappingDeclaration callinMapping) {
org.eclipse.jdt.core.dom.CallinMappingDeclaration result = this.ast
.newCallinMappingDeclaration();
@@ -7481,6 +7484,7 @@
// with { ... }, parameter mappings
if (callinMapping.mappings != null) {
+ result.setWithKeywordStart(callinMapping.bodyStart);
int mappingsLength = callinMapping.mappings.length;
for (int idx = 0; idx < mappingsLength; idx++) {
result.getParameterMappings().add(
@@ -7556,6 +7560,7 @@
// convert parameter mappings
if (calloutMapping.mappings != null) {
+ result.setWithKeywordStart(calloutMapping.bodyStart);
for (int idx = 0; idx < calloutMapping.mappings.length; idx++) {
result.getParameterMappings().add(idx,
convert(calloutMapping.mappings[idx]));
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AbstractMethodMappingDeclaration.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AbstractMethodMappingDeclaration.java
index 92aaedf..38986ab 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AbstractMethodMappingDeclaration.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/AbstractMethodMappingDeclaration.java
@@ -61,6 +61,8 @@
ASTNode.NodeList parameterMappings =
new ASTNode.NodeList(internalParameterMappingsProperty());
+ private int withKeywordStart;
+
/** Return the structural property descriptor for the roleMappingElement property of this node. */
public abstract ChildPropertyDescriptor getRoleElementProperty();
@@ -234,4 +236,20 @@
{
return this.ast.getBindingResolver().resolveMethodMapping(this);
}
+
+ /**
+ * Set the start position of the 'with' keyword starting the parameter mappings block.
+ * @since 3.28 OTDT 2.8.2
+ */
+ public void setWithKeywordStart(int withKeywordStart) {
+ this.withKeywordStart = withKeywordStart;
+ }
+
+ /**
+ * Get the start position of the 'with' keyword starting the parameter mappings block.
+ * @since 3.28 OTDT 2.8.2
+ */
+ public int getWithKeywordStart() {
+ return this.withKeywordStart;
+ }
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/GuardPredicateDeclaration.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/GuardPredicateDeclaration.java
index e0f831f..b0bd891 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/GuardPredicateDeclaration.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/GuardPredicateDeclaration.java
@@ -66,6 +66,8 @@
private Expression expression = null;
private boolean isBase = false;
+ private int whenPosition;
+
GuardPredicateDeclaration(AST ast)
{
super(ast);
@@ -198,4 +200,19 @@
return memSize() + (this.expression == null ? 0 : getExpression().treeSize());
}
+ /**
+ * Set position of the 'when' keyword (differs from start position in 'base' 'when' combination).
+ * @since 3.28
+ */
+ public void setWhenPosition(int sourceStart) {
+ this.whenPosition = sourceStart;
+ }
+
+ /**
+ * Set position of the 'when' keyword (differs from start position in 'base' 'when' combination).
+ * @since 3.28
+ */
+ public int getWhenPosition() {
+ return this.whenPosition;
+ }
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ImportDeclaration.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ImportDeclaration.java
index 50a4afd..774a8c5 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ImportDeclaration.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/ImportDeclaration.java
@@ -139,6 +139,8 @@
* @since 3.2
*/
private boolean isBase = false;
+
+ private int baseModifierPosition = -1;
// SH}
/**
* Creates a new AST node for an import declaration owned by the
@@ -422,5 +424,20 @@
memSize()
+ (this.importName == null ? 0 : getName().treeSize());
}
+
+ /**
+ * Set the start position of the 'base' modifier.
+ * @since 3.28 OTDT 2.8.2
+ */
+ public void setBaseModifierPosition(int baseModifierPosition) {
+ this.baseModifierPosition = baseModifierPosition;
+ }
+ /**
+ * Get the start position of the 'base' modifier, or -1.
+ * @since 3.28 OTDT 2.8.2
+ */
+ public int getBaseModifierPosition() {
+ return this.baseModifierPosition;
+ }
}
diff --git a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/RoleTypeDeclaration.java b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/RoleTypeDeclaration.java
index 89e72c5..a9f7506 100644
--- a/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/RoleTypeDeclaration.java
+++ b/org.eclipse.jdt.core/dom/org/eclipse/jdt/core/dom/RoleTypeDeclaration.java
@@ -378,6 +378,8 @@
*/
private boolean isRoleFile = false;
+ private int playedByPosition;
+
/**
* Creates a new AST node for a type declaration owned by the given
* AST. By default, the type declaration is for a class of an
@@ -699,6 +701,7 @@
{
RoleTypeDeclaration result = new RoleTypeDeclaration(target);
result.setSourceRange(this.getStartPosition(), this.getLength());
+ result.setPlayedByPosition(this.playedByPosition);
result.setJavadoc(
(Javadoc) ASTNode.copySubtree(target, getJavadoc()));
if (this.ast.apiLevel == AST.JLS2_INTERNAL) {
@@ -1163,4 +1166,20 @@
+ (this.teamClassType == null ? 0 : this.teamClassType.treeSize())
+ (this.optionalGuardPredicate == null ? 0 : this.optionalGuardPredicate.treeSize());
}
+
+ /**
+ * Set the start position of the 'playedBy' keyword.
+ * @since 3.28 OTDT 2.8.2
+ */
+ public void setPlayedByPosition(int playedByPosition) {
+ this.playedByPosition = playedByPosition;
+ }
+
+ /**
+ * Answer the start position of the 'playedBy' keyword.
+ * @since 3.28 OTDT 2.8.2
+ */
+ public int getPlayedByPosition() {
+ return this.playedByPosition;
+ }
}
diff --git a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/SourceElementParser.java b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/SourceElementParser.java
index 943df12..7625817 100644
--- a/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/SourceElementParser.java
+++ b/org.eclipse.jdt.core/model/org/eclipse/jdt/internal/compiler/SourceElementParser.java
@@ -785,7 +785,9 @@
impt.declarationEnd = impt.declarationSourceEnd;
//this.endPosition is just before the ;
// OT/J: consume start and end position of base:
- this.intPtr-=2;
+ impt.baseModifierPosition = this.intStack[this.intPtr--];
+ this.intPtr-=1;
+//
impt.declarationSourceStart = this.intStack[this.intPtr--];
if(!this.statementRecoveryActivated &&
diff --git a/plugins/org.eclipse.objectteams.otdt.jdt.ui/plugin.xml b/plugins/org.eclipse.objectteams.otdt.jdt.ui/plugin.xml
index a368a0c..939c12e 100644
--- a/plugins/org.eclipse.objectteams.otdt.jdt.ui/plugin.xml
+++ b/plugins/org.eclipse.objectteams.otdt.jdt.ui/plugin.xml
@@ -96,6 +96,23 @@
class="org.eclipse.objectteams.otdt.internal.ui.javaeditor.HighlightingAdaptor"
icon="platform:/plugin/org.eclipse.objectteams.otdt.ui/icons/ot/team_obj.gif"/>
<team
+ activation="NONE"
+ class="org.eclipse.objectteams.otdt.internal.ui.javaeditor.HighlightingAdaptor$OTSemanticReconciler"
+ icon="platform:/plugin/org.eclipse.objectteams.otdt.ui/icons/ot/team_obj.gif">
+ <superBase
+ class="org.eclipse.jdt.internal.ui.javaeditor.PositionCollectorCore"
+ plugin="org.eclipse.jdt.core.manipulation">
+ </superBase>
+ <superBase
+ class="org.eclipse.jdt.internal.corext.dom.GenericVisitor"
+ plugin="org.eclipse.jdt.core.manipulation">
+ </superBase>
+ <superBase
+ class="org.eclipse.jdt.core.dom.ASTVisitor"
+ plugin="org.eclipse.jdt.core">
+ </superBase>
+ </team>
+ <team
activation="ALL_THREADS"
class="org.eclipse.objectteams.otdt.internal.ui.javaeditor.AnnotationAdaptor"
icon="platform:/plugin/org.eclipse.objectteams.otdt.ui/icons/ot/team_obj.gif">
diff --git a/plugins/org.eclipse.objectteams.otdt.jdt.ui/src/org/eclipse/objectteams/otdt/internal/ui/javaeditor/HighlightingAdaptor.java b/plugins/org.eclipse.objectteams.otdt.jdt.ui/src/org/eclipse/objectteams/otdt/internal/ui/javaeditor/HighlightingAdaptor.java
index 20f64b3..a6bd6e6 100644
--- a/plugins/org.eclipse.objectteams.otdt.jdt.ui/src/org/eclipse/objectteams/otdt/internal/ui/javaeditor/HighlightingAdaptor.java
+++ b/plugins/org.eclipse.objectteams.otdt.jdt.ui/src/org/eclipse/objectteams/otdt/internal/ui/javaeditor/HighlightingAdaptor.java
@@ -1,7 +1,7 @@
/**********************************************************************
* This file is part of "Object Teams Development Tooling"-Software
*
- * Copyright 2006, 2007 Technical University Berlin, Germany.
+ * Copyright 2006, 2021 Technical University Berlin, Germany, and others.
*
* This program and the accompanying materials
* are made available under the terms of the Eclipse Public License 2.0
@@ -17,22 +17,58 @@
**********************************************************************/
package org.eclipse.objectteams.otdt.internal.ui.javaeditor;
+import java.util.List;
+
import org.eclipse.jdt.core.dom.ASTNode;
+import org.eclipse.jdt.core.dom.ASTVisitor;
+import org.eclipse.jdt.core.dom.AbstractMethodMappingDeclaration;
+import org.eclipse.jdt.core.dom.BaseCallMessageSend;
+import org.eclipse.jdt.core.dom.BaseConstructorInvocation;
+import org.eclipse.jdt.core.dom.CallinMappingDeclaration;
+import org.eclipse.jdt.core.dom.CalloutMappingDeclaration;
+import org.eclipse.jdt.core.dom.GuardPredicateDeclaration;
import org.eclipse.jdt.core.dom.IBinding;
import org.eclipse.jdt.core.dom.IVariableBinding;
+import org.eclipse.jdt.core.dom.ImportDeclaration;
+import org.eclipse.jdt.core.dom.LiftingType;
+import org.eclipse.jdt.core.dom.MethodBindingOperator;
+import org.eclipse.jdt.core.dom.MethodDeclaration;
import org.eclipse.jdt.core.dom.MethodSpec;
+import org.eclipse.jdt.core.dom.Modifier;
+import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
+import org.eclipse.jdt.core.dom.PackageDeclaration;
+import org.eclipse.jdt.core.dom.ParameterMapping;
+import org.eclipse.jdt.core.dom.PrecedenceDeclaration;
+import org.eclipse.jdt.core.dom.RoleTypeDeclaration;
+import org.eclipse.jdt.core.dom.SimpleName;
+import org.eclipse.jdt.core.dom.TSuperConstructorInvocation;
+import org.eclipse.jdt.core.dom.TSuperMessageSend;
+import org.eclipse.jdt.core.dom.Type;
+import org.eclipse.jdt.core.dom.TypeAnchor;
+import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
import org.eclipse.jdt.internal.ui.javaeditor.JavaSourceViewer;
+import org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlighting;
+import org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightingsCore;
import org.eclipse.jdt.internal.ui.javaeditor.SemanticToken;
+import org.eclipse.jdt.ui.PreferenceConstants;
import org.eclipse.jdt.ui.text.IColorManager;
+import org.eclipse.jdt.ui.text.IJavaColorConstants;
import org.eclipse.jface.preference.IPreferenceStore;
+import org.eclipse.jface.preference.PreferenceConverter;
+import org.eclipse.objectteams.otdt.core.compiler.IOTConstants;
import org.eclipse.objectteams.otdt.internal.ui.text.OutlineAdaptor;
+import org.eclipse.swt.graphics.RGB;
import base org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightingManager;
+import base org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightingManager.Highlighting;
+import base org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightingReconciler;
+import base org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightingReconciler.PositionCollector;
import base org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightings.ParameterVariableHighlighting;
+import base org.eclipse.jdt.internal.ui.javaeditor.SemanticHighlightings.RestrictedIdentifiersHighlighting;
/**
- * This aspect fixes syntax highlighting for OT/J code
+ * This aspect fixes highlighting (syntax & semantic) for OT/J code
*
* @author stephan
* @since 0.9.18
@@ -44,13 +80,26 @@
{
void myInstall()
{
+ updateKWColor();
+
//{Hack as workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=142299
OutlineAdaptor.doActivate();
// SH}
-
}
void myInstall()
<- after void install(JavaEditor je, JavaSourceViewer sv, IColorManager cm, IPreferenceStore ps);
+
+ private void updateKWColor() {
+ IPreferenceStore ps = PreferenceConstants.getPreferenceStore();
+ RGB kwRgb= PreferenceConverter.getColor(ps, IJavaColorConstants.JAVA_KEYWORD);
+ String key = PreferenceConstants.EDITOR_SEMANTIC_HIGHLIGHTING_PREFIX + SemanticHighlightingsCore.RESTRICTED_KEYWORDS + PreferenceConstants.EDITOR_SEMANTIC_HIGHLIGHTING_COLOR_SUFFIX;
+ RGB restrictedKwRgb = PreferenceConverter.getColor(ps, key);
+ if (kwRgb.equals(restrictedKwRgb) && kwRgb.equals(new RGB(127, 0, 85))) {
+ // restricted keywords share the color of regular keywords, and both are at the default value.
+ // -> modify the color for restricted keywords to orange:
+ PreferenceConverter.setValue(ps, key, new RGB(245, 121, 0));
+ }
+ }
}
/**
@@ -72,4 +121,247 @@
return false;
}
}
+
+
+ protected team class OTSemanticReconciler playedBy SemanticHighlightingReconciler {
+
+ @SuppressWarnings("basecall")
+ protected class Collector implements ILowerable playedBy PositionCollector {
+
+ @SuppressWarnings("decapsulation")
+ void addPosition(int offset, int length, HighlightingRole highlighting)
+ -> void addPosition(int offset, int length, Highlighting highlighting);
+
+ boolean visit(PackageDeclaration node) <- replace boolean visit(PackageDeclaration node);
+ callin boolean visit(PackageDeclaration node) {
+ highlightModifiers(node.modifiers(), ModifierKeyword.TEAM_KEYWORD);
+ return true;
+ }
+
+ boolean visitType(TypeDeclaration node) <- replace boolean visit(TypeDeclaration node)
+ base when (node.isTeam());
+ callin boolean visitType(TypeDeclaration node) {
+ highlightModifiers(node.modifiers(), ModifierKeyword.TEAM_KEYWORD);
+ return true;
+ }
+
+ boolean visit(RoleTypeDeclaration node) <- replace boolean visit(RoleTypeDeclaration node);
+ callin boolean visit(RoleTypeDeclaration node) {
+ if (node.isTeam()) {
+ highlightModifiers(node.modifiers(), ModifierKeyword.TEAM_KEYWORD);
+ }
+ if (node.getPlayedByPosition() != 0) {
+ highlightScopedKeyword(node.getPlayedByPosition(), "playedBy".length()); //$NON-NLS-1$
+ }
+ return true;
+ }
+
+ boolean visitMethod(MethodDeclaration node) <- replace boolean visit(MethodDeclaration node)
+ base when (isCallin(node));
+ callin boolean visitMethod(MethodDeclaration node) {
+ highlightModifiers(node.modifiers(), ModifierKeyword.CALLIN_KEYWORD);
+ return true;
+ }
+
+ @SuppressWarnings("unchecked") // modifiers() has raw type List
+ private static boolean isCallin(MethodDeclaration node) {
+ return node.modifiers().stream()
+ .filter(Modifier.class::isInstance)
+ .map(m -> ((Modifier) m).getKeyword())
+ .anyMatch(kw -> kw == ModifierKeyword.CALLIN_KEYWORD);
+ }
+
+ void highlightModifiers(List<?> modifiers, ModifierKeyword... keywords) {
+ for (Object object : modifiers) {
+ if (object instanceof Modifier) {
+ Modifier modifier = (Modifier) object;
+ for (ModifierKeyword kw : keywords) {
+ if (modifier.getKeyword() == kw)
+ highlightScopedKeyword((Modifier) object);
+ }
+ }
+ }
+ }
+
+ boolean visit(MethodBindingOperator node) <- replace boolean visit(MethodBindingOperator node);
+ callin boolean visit(MethodBindingOperator operator) {
+ Modifier modifier = operator.bindingModifier();
+ if (modifier != null) {
+ return highlightScopedKeyword(modifier);
+ }
+ return true;
+ }
+
+ <T extends AbstractMethodMappingDeclaration> boolean visit(T node) <- replace
+ boolean visit(CallinMappingDeclaration node),
+ boolean visit(CalloutMappingDeclaration node);
+ callin <T extends AbstractMethodMappingDeclaration> boolean visit(T node) {
+ if (node.getWithKeywordStart() > 0)
+ highlightScopedKeyword(node.getWithKeywordStart(), "with".length()); //$NON-NLS-1$
+ return true;
+ }
+
+ boolean visit(ParameterMapping node) <- replace boolean visit(ParameterMapping node);
+ callin boolean visit(ParameterMapping node) {
+ ASTNode methodMapping = node.getParent();
+ // this paragraph "copied" from ReplaceResultReferenceVisitor
+ boolean isResultDir = false;
+ if (methodMapping instanceof CallinMappingDeclaration) {
+ isResultDir = !node.isBindIN();
+ if (!isResultDir
+ && ((CallinMappingDeclaration) methodMapping).bindingOperator().getBindingModifier() == Modifier.OT_AFTER_CALLIN) {
+ isResultDir = true;
+ }
+ } else {
+ isResultDir = node.isBindIN();
+ }
+ //
+ String resultString = String.valueOf(IOTConstants.RESULT);
+ if (isResultDir) {
+ node.getExpression().accept(
+ new ASTVisitor() {
+ public boolean visit(SimpleName name) {
+ if (resultString.equals(name.getIdentifier())) {
+ highlightScopedKeyword(name);
+ }
+ return false;
+ }
+ });
+ }
+ if (resultString.equals(node.getIdentifier().getIdentifier()))
+ highlightScopedKeyword(node.getIdentifier());
+ return false;
+ }
+
+ boolean visit(LiftingType node) <- replace boolean visit(LiftingType node);
+ callin boolean visit(LiftingType node) {
+ // highlight everything between base type and role type
+ Type baseType = node.getBaseType();
+ int start = baseType.getStartPosition()+baseType.getLength()+1;
+ highlightScopedKeyword(start, node.getRoleType().getStartPosition()-start);
+ return false;
+ }
+
+
+ boolean visit(BaseCallMessageSend node) <- replace boolean visit(BaseCallMessageSend node);
+ callin boolean visit(BaseCallMessageSend node) {
+ return highlightScopedKeyword(node.getStartPosition(), 4);
+ }
+
+ boolean visit(BaseConstructorInvocation node) <- replace boolean visit(BaseConstructorInvocation node);
+ callin boolean visit(BaseConstructorInvocation node) {
+ return highlightScopedKeyword(node);
+ }
+
+ void visitTSuper(ASTNode node) <- after
+ boolean visit(TSuperMessageSend node),
+ boolean visit(TSuperConstructorInvocation node);
+ void visitTSuper(ASTNode node) {
+ highlightScopedKeyword(node.getStartPosition(), "tsuper".length()); //$NON-NLS-1$
+ }
+
+ boolean visit(GuardPredicateDeclaration node) <- replace boolean visit(GuardPredicateDeclaration node);
+ callin boolean visit(GuardPredicateDeclaration node) {
+ if (node.isBase()) {
+ highlightScopedKeyword(node.getStartPosition(), 4);
+ }
+ return highlightScopedKeyword(node.getWhenPosition(), 4);
+ }
+
+ boolean visitImport(ImportDeclaration node) <- replace boolean visit(ImportDeclaration node)
+ base when (node.isBase());
+ callin boolean visitImport(ImportDeclaration node) {
+ return highlightScopedKeyword(node.getBaseModifierPosition(), 4);
+ }
+
+ boolean visit(TypeAnchor node) <- replace boolean visit(TypeAnchor node);
+ callin boolean visit(TypeAnchor node) {
+ if (node.getPath() == null) {
+ // assumed to be a 'base' anchor
+ return highlightScopedKeyword(node);
+ }
+ return false;
+ }
+
+ boolean visit(PrecedenceDeclaration node) <- replace boolean visit(PrecedenceDeclaration node);
+ callin boolean visit(PrecedenceDeclaration node) {
+ int length = "precedence".length(); //$NON-NLS-1$
+ if (node.isAfter())
+ length += " after".length(); //$NON-NLS-1$ // Note: this is not exact
+ return highlightScopedKeyword(node.getStartPosition(), length);
+ }
+
+ /** Apply the 'restricted identifiers' styling to the given node. */
+ private boolean highlightScopedKeyword(ASTNode node) {
+ return highlightScopedKeyword(node.getStartPosition(), node.getLength());
+ }
+ private boolean highlightScopedKeyword(int offset, int length) {
+ if (offset > -1 && length > 0) {
+ SemanticHighlighting[] jobSemanticHighlightings = getFJobSemanticHighlightings();
+ if (jobSemanticHighlightings != null) {
+ for (int i= 0; i < jobSemanticHighlightings.length; i++) {
+ if (typeTester.isRestrictedIdentifierHighlighting(jobSemanticHighlightings[i])) {
+ addPosition(offset, length, getFJobHighlighting(i));
+ return false;
+ }
+ }
+ }
+ }
+ return true;
+ }
+
+ }
+
+ @SuppressWarnings("decapsulation")
+ SemanticHighlighting[] getFJobSemanticHighlightings() -> get SemanticHighlighting[] fJobSemanticHighlightings;
+
+ @SuppressWarnings("decapsulation")
+ HighlightingRole getFJobHighlighting(int i) -> get Highlighting[] fJobHighlightings with {
+ result <- fJobHighlightings[i]
+ }
+
+ install <- after install;
+ private void install() {
+ this.activate(ALL_THREADS);
+ }
+ uninstall <- after uninstall;
+ private void uninstall() {
+ this.deactivate(ALL_THREADS);
+ HighlightingAdaptor.this.unregisterRole(this);
+ }
+
+ /*
+ RestrictedHighlighting[] getFJobHighlightings() -> get Highlighting[] fJobHighlightings;
+ crash from m.invoke(target, offset, length, getFJobHighlightings()[i]);
+ java.lang.ArrayIndexOutOfBoundsException: Index 2 out of bounds for length 2
+ at org.eclipse.objectteams.otdt.internal.core.compiler.statemachine.transformer.InsertTypeAdjustmentsVisitor.endVisit(InsertTypeAdjustmentsVisitor.java:144)
+ at org.eclipse.jdt.internal.compiler.ast.MessageSend.traverse(MessageSend.java:1790)
+ at org.eclipse.jdt.internal.compiler.ast.Block.resolveUsing(Block.java:184)
+ at org.eclipse.jdt.internal.compiler.ast.TryStatement.resolve(TryStatement.java:1235)
+ at org.eclipse.jdt.internal.compiler.ast.Block.resolve(Block.java:149)
+ at org.eclipse.jdt.internal.compiler.ast.IfStatement.resolveIfStatement(IfStatement.java:294)
+ at org.eclipse.jdt.internal.compiler.ast.IfStatement.resolve(IfStatement.java:320)
+ at org.eclipse.jdt.internal.compiler.ast.Block.resolve(Block.java:149)
+ at org.eclipse.jdt.internal.compiler.ast.ForeachStatement.resolve(ForeachStatement.java:723)
+ at org.eclipse.jdt.internal.compiler.ast.AbstractMethodDeclaration.resolveStatements(AbstractMethodDeclaration.java:977)
+ */
+ }
+
+ RestrictedIdentifiersHighlightingRole typeTester = new RestrictedIdentifiersHighlightingRole();
+
+ @SuppressWarnings("decapsulation") // overrides finalness
+ protected class RestrictedIdentifiersHighlightingRole implements ILowerable playedBy RestrictedIdentifiersHighlighting {
+ Class<?> restrictedIdentifiersHighlightingClass;
+ protected RestrictedIdentifiersHighlightingRole() {
+ base();
+ ILowerable role = this;
+ restrictedIdentifiersHighlightingClass = role.lower().getClass(); // this class cannot be used in source-level instanceof checks!
+ }
+ public boolean isRestrictedIdentifierHighlighting(SemanticHighlighting highlighting) {
+ return restrictedIdentifiersHighlightingClass.isInstance(highlighting);
+ }
+ }
+
+ /** Empty role as handle for unmentionable base class. */
+ protected class HighlightingRole playedBy Highlighting { /* empty */ }
}
diff --git a/plugins/org.eclipse.objectteams.otdt.jdt.ui/src/org/eclipse/objectteams/otdt/internal/ui/javaeditor/JavaEditorAdaptor.java b/plugins/org.eclipse.objectteams.otdt.jdt.ui/src/org/eclipse/objectteams/otdt/internal/ui/javaeditor/JavaEditorAdaptor.java
index d33cbb3..5c41d55 100644
--- a/plugins/org.eclipse.objectteams.otdt.jdt.ui/src/org/eclipse/objectteams/otdt/internal/ui/javaeditor/JavaEditorAdaptor.java
+++ b/plugins/org.eclipse.objectteams.otdt.jdt.ui/src/org/eclipse/objectteams/otdt/internal/ui/javaeditor/JavaEditorAdaptor.java
@@ -21,22 +21,17 @@
**********************************************************************/
package org.eclipse.objectteams.otdt.internal.ui.javaeditor;
-import org.eclipse.jdt.core.IType;
-import org.eclipse.jdt.core.ITypeRoot;
+import org.eclipse.jdt.core.IType;
+import org.eclipse.jdt.core.ITypeRoot;
import org.eclipse.jdt.core.dom.CompilationUnit;
import org.eclipse.jdt.core.manipulation.SharedASTProviderCore;
-import org.eclipse.jdt.ui.JavaUI;
import org.eclipse.jface.text.rules.IToken;
-import org.eclipse.jface.text.source.IAnnotationModel;
-import org.eclipse.ui.IEditorInput;
-import org.eclipse.ui.texteditor.ITextEditor;
-import org.eclipse.objectteams.otdt.core.OTModelManager;
-import org.eclipse.objectteams.otdt.internal.ui.javaeditor.RoleOverrideIndicatorManager;
+import org.eclipse.jface.text.source.IAnnotationModel;
+import org.eclipse.objectteams.otdt.core.OTModelManager;
-import base org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;
-import base org.eclipse.jdt.internal.ui.javaeditor.JavaEditor;
-import base org.eclipse.jdt.ui.text.JavaSourceViewerConfiguration;
-import base org.eclipse.jdt.internal.ui.text.CombinedWordRule.WordMatcher;
+import base org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;
+import base org.eclipse.jdt.internal.ui.text.CombinedWordRule.WordMatcher;
+import base org.eclipse.jdt.ui.text.JavaSourceViewerConfiguration;
/**
@@ -49,29 +44,7 @@
@SuppressWarnings({"restriction", "inferredcallout", "decapsulation"})
public team class JavaEditorAdaptor {
- /**
- * For source and class file editors: figure out whether the input is OT source of plain Java.
- */
- protected class JavaEditor playedBy JavaEditor
- {
- /**
- * True if we can positively tell that the editor's input contains
- * a valid non-OT java type (we default to the OT-behavior).
- */
- protected boolean isSourcePlainJava = false;
-
- /** We need the editor input to figure out OT vs. Java source. */
- protected void analyzeInput(IEditorInput input) {
- ITypeRoot typeRoot = JavaUI.getEditorInputTypeRoot(input);
- if (typeRoot != null) {
- IType primaryType = typeRoot.findPrimaryType();
- if (primaryType != null)
- isSourcePlainJava = !OTModelManager.hasOTElementFor(primaryType);
- }
- }
- void analyzeInput(IEditorInput input) <- before void doSetInput(IEditorInput input);
- }
- protected class CompilationUnitEditor extends JavaEditor playedBy CompilationUnitEditor {
+ protected class CompilationUnitEditor playedBy CompilationUnitEditor {
// this instance manages the override indicator for role classes:
RoleOverrideIndicatorManager fRoleOverrideIndicatorManager;
@@ -83,15 +56,18 @@
}
}
- installOverrideIndicator <- after installOverrideIndicator
- when (!isSourcePlainJava);
+ installOverrideIndicator <- after installOverrideIndicator;
protected void installOverrideIndicator(boolean provideAST) {
// verbatim repeat:
IAnnotationModel model = getDocumentProvider().getAnnotationModel(getEditorInput());
final ITypeRoot inputElement = getInputJavaElement();
if (model == null || inputElement == null)
return;
- //own:
+ //own:
+ IType primaryType = inputElement.findPrimaryType();
+ if (primaryType != null && !OTModelManager.hasOTElementFor(primaryType))
+ return; // plain Java
+
fRoleOverrideIndicatorManager = new RoleOverrideIndicatorManager(model, inputElement, null);
if (provideAST) {
@@ -104,12 +80,7 @@
final static String LAST_JAVA_KEYWORD = "while"; //$NON-NLS-1$
final static String WITHIN_KEYWORD = "within"; //$NON-NLS-1$
- @SuppressWarnings("nls")
- final static String[] OTJ_KEYWORDS = {
- WITHIN_KEYWORD, "base", "tsuper", "callin", "playedBy", "with", "team", "as",
- "result", "replace", "after", "before", "when", "get", "set", "precedence"
- };
-
+
protected team class JavaSourceViewerConfiguration playedBy JavaSourceViewerConfiguration
{
callin void initializeScanners() {
@@ -117,18 +88,9 @@
base.initializeScanners();
}
initializeScanners <- replace initializeScanners;
-
- /** Fetch the editor role, but only if base side type is compatible. */
- JavaEditor getEditor() -> ITextEditor getEditor()
- with { result <- (JavaEditor)(result instanceof JavaEditor ? result : null) }
- /** Is the editor configured for plain Java source? */
- protected boolean isSourcePlainJava() {
- JavaEditor editor = getEditor();
- return editor != null && editor.isSourcePlainJava;
- }
- /** Add the OT/J keywords to the matcher. This role is only active during initializeScanners(). */
+ /** Add the OT/J keyword 'within' to the matcher. This role is only active during initializeScanners(). */
protected class WordMatcher playedBy WordMatcher {
void addWord(String word, IToken token) <- replace void addWord(String word, IToken token);
@@ -137,11 +99,7 @@
callin void addWord(String word, IToken token) {
base.addWord(word, token);
if (LAST_JAVA_KEYWORD.equals(word)) {
- if (JavaSourceViewerConfiguration.this.isSourcePlainJava())
- base.addWord(WITHIN_KEYWORD, token); // in plain java mode "within" is our only keyword
- else
- for (int i=0; i<OTJ_KEYWORDS.length; i++)
- base.addWord(OTJ_KEYWORDS[i], token);
+ base.addWord(WITHIN_KEYWORD, token); // in plain java mode "within" is our only keyword
}
}
}