0.22.0 - Fix a Java class signature parsing bug and a C# full type name resolution bug.

Author: TeamworkGuy2

CHANGELOG.md

@@ -4,7 +4,17 @@ This project does its best to adhere to [Semantic Versioning](http://semver.org/
 
 
 --------
-### [0.21.0](https://github.com/TeamworkGuy2/JParseCode/commit/7482a2a148a5f42e230c33897d3f17d907c5348f) - 2020-11-22
+### [0.22.0](N/A) - 2020-04-18
+#### Removed
+* `ProjectClassSet` `resolveSimpleName()` in favor of moving the two lines of code to the single calling location
+
+#### Fixed
+* C# full type name resolution fixed to resolve against the parent namespaces the class resides in (affects types in class signatures, method signatures, and fields)
+* Java class signature parsing fixed to support both `extends` and implements in the same signature `implements` (can't believe I overlooked this and didn't have a unit test)
+
+
+--------
+### [0.21.0](https://github.com/TeamworkGuy2/JParseCode/commit/e6177edf59fb46bd8edcd830f0cf720eb44206b5) - 2020-11-26
 __Parsing performance optimizations (~15-20%)__
 #### Changed
 * Update dependencies `jtext-tokenizer@0.7.0` and `jtext-parser@0.18.0`

bin/jparse_code-with-tests.jar

@@ -1,5 +1,5 @@
 {
-	"version" : "0.21.0",
+	"version" : "0.22.0",
 	"name" : "jparse-code",
 	"description" : "An in-progress suite of parsing/transpilation tools for C#, Java, and TypeScript code.  Generates simple JSON ASTs.",
 	"homepage" : "https://github.com/TeamworkGuy2/JParseCode",

bin/jparse_code.jar

@@ -0,0 +1,15 @@
+
+namespace ParserExamples {
+
+    /// <summary>
+    /// Base class for this project.
+    /// </summary>
+    /// <threadsafety>
+    /// This class is mutable. And it is not thread-safe.
+    /// </threadsafety>
+    public abstract class BaseClass {
+
+        /// <summary>A string representation of this instance.</value>
+        public virtual string ToString();
+    }
+}

package-lib.json

@@ -1,17 +1,17 @@
 using System;
 using System.Runtime.Serialization;
 
-namespace ParserExamples.Models {
-
+namespace ParserExamples.Models
+{
     /// <summary>
     /// A class representing a Track.
     /// </summary>
     /// <threadsafety>
     /// This class is mutable. And it is not thread-safe.
     /// </threadsafety>
     [DataContract]
-    public class TrackInfo : ISerializable, IComparable<TrackInfo> {
-
+    public class TrackInfo : BaseClass, ISerializable, IComparable<TrackInfo>
+	{
         /// <value>The track name.</value>
         [DataMember]
         public string Name { get; set; }
@@ -41,5 +41,4 @@ public TType Refresh<TType>(TType tt) where TType : IConvertible {
             return tt;
         }
     }
-
 }

rsc/csharp/ParserExamples/BaseClass.cs

@@ -0,0 +1,11 @@
+package ParserExamples;
+
+/// <summary>
+/// Base class for this project.
+/// </summary>
+public abstract class AlbumInfo {
+
+	/// <summary>A string representation of this instance.</value>
+	public String toString();
+
+}

rsc/csharp/ParserExamples/Models/TrackInfo.cs

@@ -11,7 +11,7 @@
 /// This class is mutable. And it is not thread-safe.
 /// </threadsafety>
 @DataContract
-public class TrackInfo implements Serializable, Comparable<TrackInfo> {
+public class TrackInfo extends BaseClass implements Serializable, Comparable<TrackInfo> {
 
 	/// <value>The track name.</value>
 	@DataMember

rsc/java/ParserExamples/BaseClass.java

@@ -14,7 +14,6 @@
 import twg2.ast.interm.field.FieldSig;
 import twg2.ast.interm.method.MethodSigSimple;
 import twg2.ast.interm.type.TypeSig;
-import twg2.collections.dataStructures.BaseList;
 import twg2.parser.codeParser.AstExtractor;
 import twg2.parser.codeParser.extractors.AccessModifierExtractor;
 import twg2.parser.codeParser.extractors.BlockExtractor;
@@ -179,53 +178,62 @@ public static void _extractBlocksFromTree(List<String> nameScope, SimpleTree<Cod
 	}
 
 
-	/** Reads backward from a '{' block through a simple class signature ({@code ClassName [: ClassName]}).
+	/** Reads backward from a '{' block through a simple class signature ({@code ClassName [: ClassName, ClassName, ...]}).
 	 * Returns the iterator where {@code next()} would return the class name element.
-	 * @return {@code <className, extendImplementNames>}
+	 * @return {@code <className, extendImplementNames[]>}
 	 */
 	private static Entry<String, List<String>> readClassIdentifierAndExtends(ListIterator<SimpleTree<CodeToken>> iter) {
 		var keywordUtil = CodeLanguageOptions.C_SHARP.getKeywordUtil();
 		// class signatures are read backward from the opening '{'
 		int prevCount = 0;
 		var names = new ArrayList<String>();
+		boolean lastNodeWasInheritanceKeyword = false;
 		Entry<String, List<String>> nameCompoundRes = null;
 
-		// get the first element and begin checking
+		// get the node and begin checking backward
 		if(iter.hasPrevious()) { prevCount++; }
 		SimpleTree<CodeToken> prevNode = iter.hasPrevious() ? iter.previous() : null;
 
-		while(prevNode != null && AstFragType.isIdentifierOrKeyword(prevNode.getData()) && !keywordUtil.blockModifiers().is(prevNode.getData()) && !keywordUtil.isInheritanceKeyword(prevNode.getData().getText())) {
+		while(prevNode != null && (AstFragType.isIdentifierOrKeyword(prevNode.getData()) || keywordUtil.isInheritanceKeyword(prevNode.getData().getText())) && !keywordUtil.blockModifiers().is(prevNode.getData())) {
 			// found an object initializer in the form 'new [Abc] {', not a class/interface definition so return nothing
 			if(names.size() < 2 && CsKeyword.NEW.toSrc().equals(prevNode.getData().getText())) {
 				break;
 			}
-			names.add(prevNode.getData().getText());
-			prevNode = iter.hasPrevious() ? iter.previous() : null;
-			if(iter.hasPrevious()) { prevCount++; }
-		}
 
-		// if the class signature extends/implements, then the identifiers just read are the class/interface names, next read the actual class name
-		if(prevNode != null && prevNode.getData().getText().equals(":")) {
-			prevNode = iter.hasPrevious() ? iter.previous() : null;
-			if(iter.hasPrevious()) { prevCount++; }
-			if(prevNode != null && AstFragType.isIdentifierOrKeyword(prevNode.getData()) && !keywordUtil.blockModifiers().is(prevNode.getData())) {
-				Collections.reverse(names);
-				var extendImplementNames = names;
-				String className = prevNode.getData().getText();
-				nameCompoundRes = Tuples.of(className, extendImplementNames);
+			if(!keywordUtil.isInheritanceKeyword(prevNode.getData().getText())) {
+				names.add(prevNode.getData().getText());
+				lastNodeWasInheritanceKeyword = false;
 			}
 			else {
-				throw new IllegalStateException("found block with extend/implement names, but no class name " + names);
+				lastNodeWasInheritanceKeyword = true;
 			}
+
+			if(iter.hasPrevious()) { prevCount++; }
+			prevNode = iter.hasPrevious() ? iter.previous() : null;
+		}
+
+		// syntax check, ensure there's a class name identifier between the block modifier and inheritance keyword ':'
+		if(lastNodeWasInheritanceKeyword) {
+			throw new IllegalStateException("found class inheritance keyword ':' with no class name preceeding it, found '" + String.valueOf(prevNode) + "'");
 		}
-		// else, we should have only read one name with the loop and it is the class name
-		else if(names.size() == 1) {
-			String className = names.get(0);
-			nameCompoundRes = Tuples.of(className, Collections.emptyList());
-			// move iterator forward since the while loop doesn't use the last value (i.e. reads one element past the valid elements it wants to consume)
-			if(prevCount > 0) {
-				iter.next();
+
+		// move iterator forward since the while loop reads past the class name to the first block modifier
+		if(prevCount > 0) {
+			iter.next();
+		}
+
+		// if a likely valid class block modifier has been reached, then the identifiers just read are the class/interface names and the class name
+		if(prevNode != null && keywordUtil.blockModifiers().is(prevNode.getData())) {
+			// TODO this is valid for the code: 'method<T>() where T : class { ... }'
+			if(names.size() == 0) {
+				return null;
+				//throw new IllegalStateException("found block with no name");
 			}
+
+			String className = names.remove(names.size() - 1);
+			if(names.size() > 1) { Collections.reverse(names); }
+			var extendImplementNames = names;
+			nameCompoundRes = Tuples.of(className, extendImplementNames);
 		}
 
 		return nameCompoundRes;

rsc/java/ParserExamples/Models/TrackInfo.java

@@ -14,7 +14,6 @@
 import twg2.ast.interm.field.FieldSig;
 import twg2.ast.interm.method.MethodSigSimple;
 import twg2.ast.interm.type.TypeSig;
-import twg2.collections.dataStructures.BaseList;
 import twg2.collections.interfaces.ListReadOnly;
 import twg2.parser.codeParser.AstExtractor;
 import twg2.parser.codeParser.extractors.AccessModifierExtractor;
@@ -197,50 +196,60 @@ private static String parsePackageDeclaration(SimpleTree<CodeToken> astTree) {
 	}
 
 
-	/** Reads backward from a '{' block through a simple class signature ({@code ClassName [extends ClassName] [implements InterfaceNme]}).
+	/** Reads backward from a '{' block through a simple class signature ({@code ClassName [extends ClassName] [implements InterfaceName, InterfaceName, ...]}).
 	 * Returns the iterator where {@code next()} would return the class name element.
-	 * @return {@code <className, extendImplementNames>}
+	 * @return {@code <className, extendImplementNames[]>}
 	 */
 	private static Entry<String, List<String>> readClassIdentifierAndExtends(ListIterator<SimpleTree<CodeToken>> iter) {
-		var lang = CodeLanguageOptions.JAVA;
-		var keywordUtil = lang.getKeywordUtil();
+		var keywordUtil = CodeLanguageOptions.JAVA.getKeywordUtil();
 		// class signatures are read backward from the opening '{'
 		int prevCount = 0;
 		var names = new ArrayList<String>();
+		boolean lastNodeWasInheritanceKeyword = false;
 		Entry<String, List<String>> nameCompoundRes = null;
 
-		// get the first element and begin checking
+		// get the node and begin checking backward
 		if(iter.hasPrevious()) { prevCount++; }
 		SimpleTree<CodeToken> prevNode = iter.hasPrevious() ? iter.previous() : null;
 
-		while(prevNode != null && AstFragType.isIdentifierOrKeyword(prevNode.getData()) && !keywordUtil.blockModifiers().is(prevNode.getData()) && !keywordUtil.isInheritanceKeyword(prevNode.getData().getText())) {
-			names.add(prevNode.getData().getText());
-			prevNode = iter.hasPrevious() ? iter.previous() : null;
-			if(iter.hasPrevious()) { prevCount++; }
-		}
-
-		// if the class signature extends/implements, then the identifiers just read are the class/interface names, next read the actual class name
-		if(prevNode != null && lang.getAstUtil().isKeyword(prevNode.getData(), JavaKeyword.EXTENDS, JavaKeyword.IMPLEMENTS)) {
-			prevNode = iter.hasPrevious() ? iter.previous() : null;
-			if(iter.hasPrevious()) { prevCount++; }
-			if(prevNode != null && AstFragType.isIdentifierOrKeyword(prevNode.getData()) && !keywordUtil.blockModifiers().is(prevNode.getData())) {
-				Collections.reverse(names);
-				var extendImplementNames = names;
-				String className = prevNode.getData().getText();
-				nameCompoundRes = Tuples.of(className, extendImplementNames);
+		// read all identifiers until a block modifier is reached, including inheritance keywords (i.e. 'extends' and 'implements')
+		// this creates a backward list of 'implements' class names, then 'extends' class names, then the actual class name
+		while(prevNode != null && AstFragType.isIdentifierOrKeyword(prevNode.getData()) && !keywordUtil.blockModifiers().is(prevNode.getData())) {
+			if(!keywordUtil.isInheritanceKeyword(prevNode.getData().getText())) {
+				names.add(prevNode.getData().getText());
+				lastNodeWasInheritanceKeyword = false;
 			}
+			// basic syntax checking to make sure there's an identifier between 'extends'/'implements' keywords
 			else {
-				throw new IllegalStateException("found block with extend/implement names, but no class name " + names);
+				if(lastNodeWasInheritanceKeyword) {
+					throw new IllegalStateException("found two adjacent 'extends'/'implements' keywords with no intermediate class name");
+				}
+				lastNodeWasInheritanceKeyword = true;
 			}
+
+			if(iter.hasPrevious()) { prevCount++; }
+			prevNode = iter.hasPrevious() ? iter.previous() : null;
+		}
+
+		// syntax check, ensure there's a class name identifier between the block modifier and 'extends'/'implements' keyword
+		if(lastNodeWasInheritanceKeyword) {
+			throw new IllegalStateException("found 'extends'/'implements' keyword but no class name");
+		}
+
+		// move iterator forward since the while loop reads past the class name to the first block modifier
+		if(prevCount > 0) {
+			iter.next();
 		}
-		// else, we should have only read one name with the loop and it is the class name
-		else if(names.size() == 1) {
-			String className = names.get(0);
-			nameCompoundRes = Tuples.of(className, Collections.emptyList());
-			// move iterator forward since the while loop doesn't use the last value (i.e. reads one element past the valid elements it wants to consume)
-			if(prevCount > 0) {
-				iter.next();
+
+		// if a likely valid class block modifier has been reached, then the identifiers just read are the class/interface names and the class name
+		if(prevNode != null && keywordUtil.blockModifiers().is(prevNode.getData())) {
+			if(names.size() == 0) {
+				throw new IllegalStateException("found block with no name");
 			}
+			String className = names.remove(names.size() - 1);
+			if(names.size() > 1) { Collections.reverse(names); }
+			var extendImplementNames = names;
+			nameCompoundRes = Tuples.of(className, extendImplementNames);
 		}
 
 		return nameCompoundRes;