Fix 436653: conditional aspect activation plus various polish

Modified test expectation system so it is possible to say
the test cares about one particular message and the rest
do not matter (prefix message string with '*') - crude but
quick.

Polished many places to exploit generics

Upgraded all the tests to work on Java8 - some serious changes
regarding ajdoc on Java8. Hopefully it has stayed backwards
compatible with earlier JDK versions (e.g. if using AspectJ 1.8.3+
with a JDK less than 8) but no explicit testing done for this.

ajdoc/.isJava5

+  

ajdoc/.settings/org.eclipse.jdt.core.prefs

-#Thu Oct 06 08:32:56 PDT 2005
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=disabled
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.1
-org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
-org.eclipse.jdt.core.compiler.compliance=1.3
-org.eclipse.jdt.core.compiler.debug.lineNumber=generate
-org.eclipse.jdt.core.compiler.debug.localVariable=generate
-org.eclipse.jdt.core.compiler.debug.sourceFile=generate
-org.eclipse.jdt.core.compiler.problem.assertIdentifier=ignore
-org.eclipse.jdt.core.compiler.problem.enumIdentifier=ignore
-org.eclipse.jdt.core.compiler.source=1.3

ajdoc/src/org/aspectj/tools/ajdoc/HtmlDecorator.java

 					classStartIndex = fileContents.toString().indexOf("<H2>\nClass ");
 					br = false;
 				}
-				if (classStartIndex != -1) {
+				if (classStartIndex == -1) {
+					// Java8 looks more like this:
+					// <h2 title="Class A" class="title">Class A</h2>
+					classStartIndex = fileContents.toString().indexOf("<h2 title=\"Class ");
+					int classEndIndex = fileContents.toString().indexOf("</h2>", classStartIndex);
+					if (classEndIndex != -1) {
+						// Convert it to "<h2 title="Aspect A" class="title">Aspect A</h2>"
+						String classLine = fileContents.toString().substring(classStartIndex, classEndIndex);
+						String aspectLine = classLine.replaceAll("Class ","Aspect ");
+						fileContents.delete(classStartIndex, classEndIndex);
+						fileContents.insert(classStartIndex, aspectLine);
+					}
+				}
+				else if (classStartIndex != -1) {
 					int classEndIndex = fileContents.toString().indexOf("</H2>", classStartIndex);
 					if (classStartIndex != -1 && classEndIndex != -1) {
 						String classLine = fileContents.toString().substring(classStartIndex, classEndIndex);
 						fileContents.insert(secondClassStartIndex, sb.toString());
 					}
 				}
+				else {
+					// Java8:
+					// <pre>static class <span class="typeNameLabel">ClassA.InnerAspect</span>
+					classStartIndex = fileContents.toString().indexOf("class <span class=\"typeNameLabel\">");
+					int classEndIndex = fileContents.toString().indexOf("</span>", classStartIndex);
+					if (classEndIndex != -1) {
+						// Convert it to "aspect <span class="typeNameLabel">ClassA.InnerAspect</span>"
+						String classLine = fileContents.toString().substring(classStartIndex, classEndIndex);
+						String aspectLine = "aspect"+fileContents.substring(classStartIndex+5,classEndIndex);
+						fileContents.delete(classStartIndex, classEndIndex);
+						fileContents.insert(classStartIndex, aspectLine);
+					}
+				}
 			}
 		}
 		file.delete();

ajdoc/testsrc/org/aspectj/tools/ajdoc/AjdocOutputChecker.java

 	}
 
 	/**
-	 * Returns those strings from the given array which aren't in the
-	 * html file
+	 * Returns those strings from the given array which aren't in the html file.
 	 * 
 	 * @param htmlFile
 	 * @param an array of requiredStrings
 	 * @return a List of those strings not found
 	 * @throws Exception
 	 */	
-	public static List /*String*/ getMissingStringsInFile(File htmlFile,
-			String[] requiredStrings) throws Exception {
-		List missingStrings = new ArrayList();
+	public static List<String> getMissingStringsInFile(File htmlFile, String[] requiredStrings) throws Exception {
+		List<String> missingStrings = new ArrayList<String>();
 		for (int i = 0; i < requiredStrings.length; i++) {
 			String string = requiredStrings[i];
-			if (!containsString(htmlFile,string)) {
+			if (!containsString(htmlFile, string)) {
 				missingStrings.add(string);
 			}
 		}

ajdoc/testsrc/org/aspectj/tools/ajdoc/CoverageTestCase.java

 import java.io.File;
 import java.util.List;
 
+import org.aspectj.util.FileUtil;
 import org.aspectj.util.LangUtil;
 
+import com.sun.org.apache.xml.internal.serializer.utils.Utils;
+
 
 /**
  * A long way to go until full coverage, but this is the place to add more.
         
 		// ensure that the file is entitled "Aspect ClassA.InnerAspect" rather
 		// than "Class ClassA.InnerAspect"
-		String[] strings = { "Aspect ClassA.InnerAspect",
+		
+		String[] strings = null;
+		if (LangUtil.is18VMOrGreater()) {
+			strings = new String[] {
+				"Aspect ClassA.InnerAspect",
+				"<pre>static aspect <span class=\"typeNameLabel\">ClassA.InnerAspect</span>",
+				"Class ClassA.InnerAspect",
+				"<pre>static class <span class=\"typeNameLabel\">ClassA.InnerAspect</span>"};
+		}
+		else {
+			strings = new String[] {
+				"Aspect ClassA.InnerAspect",
 				"<PRE>static aspect <B>ClassA.InnerAspect</B><DT>extends java.lang.Object</DL>",
 				"Class ClassA.InnerAspect",
 				"<PRE>static class <B>ClassA.InnerAspect</B><DT>extends java.lang.Object</DL>"};
-		List missing = AjdocOutputChecker.getMissingStringsInFile(htmlFile,strings);
-		assertEquals("There should be 2 missing strings",2,missing.size());
-		assertTrue(htmlFile.getName() + " should not have Class as it's title",missing.contains("Class ClassA.InnerAspect"));
-		assertTrue(htmlFile.getName() + " should not have class in its subtitle",missing.contains("<PRE>static class <B>ClassA.InnerAspect</B><DT>extends java.lang.Object</DL>"));
+		}
+		List<String> missingStrings = AjdocOutputChecker.getMissingStringsInFile(htmlFile,strings);
+		StringBuilder buf = new StringBuilder();
+		for (String str:missingStrings) {
+			buf.append(str).append("\n");
+		}
+		buf.append("HTMLFILE=\n").append(htmlFile).append("\n");
+		assertEquals("There should be 2 missing strings:\n"+buf.toString(), 2, missingStrings.size());
+		assertTrue(htmlFile.getName() + " should not have Class as it's title",
+				missingStrings.contains("Class ClassA.InnerAspect"));
+		if (LangUtil.is18VMOrGreater()) {
+			assertTrue(htmlFile.getName() + " should not have class in its subtitle",
+					missingStrings.contains("<pre>static class <span class=\"typeNameLabel\">ClassA.InnerAspect</span>"));
+		}
+		else {
+			assertTrue(htmlFile.getName() + " should not have class in its subtitle",
+					missingStrings.contains("<PRE>static class <B>ClassA.InnerAspect</B><DT>extends java.lang.Object</DL>"));
+		}
 		
 		// get the html file for the enclosing class
         File htmlFileClass = new File(getAbsolutePathOutdir() + "/foo/ClassA.html");
         
 		// ensure that the file is entitled "Class ClassA" and
 		// has not been changed to "Aspect ClassA"
-		String[] classStrings = { "Class ClassA</H2>",
-				"public abstract class <B>ClassA</B><DT>extends java.lang.Object<DT>",
+		String[] classStrings = null;
+		
+		if (LangUtil.is18VMOrGreater()) {
+			classStrings = new String[] {
+				"Class ClassA</h2>",
+				"public abstract class <span class=\"typeNameLabel\">ClassA</span>",
 				"Aspect ClassA</H2>",
-				"public abstract aspect <B>ClassA</B><DT>extends java.lang.Object<DT>"};
+				"public abstract aspect <span class=\"typeNameLabel\">ClassA</span>"};
+		}
+		else {
+			classStrings = new String[] {
+					"Class ClassA</H2>",
+					"public abstract class <B>ClassA</B><DT>extends java.lang.Object<DT>",
+					"Aspect ClassA</H2>",
+					"public abstract aspect <B>ClassA</B><DT>extends java.lang.Object<DT>"};
+		}
 		List classMissing = AjdocOutputChecker.getMissingStringsInFile(htmlFileClass,classStrings);
-		assertEquals("There should be 2 missing strings",2,classMissing.size());
+		assertEquals("There should be 2 missing strings:\n"+classMissing,2,classMissing.size());
 		assertTrue(htmlFileClass.getName() + " should not have Aspect as it's title",classMissing.contains("Aspect ClassA</H2>"));
-		assertTrue(htmlFileClass.getName() + " should not have aspect in its subtitle",classMissing.contains("public abstract aspect <B>ClassA</B><DT>extends java.lang.Object<DT>"));
+		if (LangUtil.is18VMOrGreater()) {
+			assertTrue(htmlFileClass.getName() + " should not have aspect in its subtitle",
+					classMissing.contains("public abstract aspect <span class=\"typeNameLabel\">ClassA</span>"));			
+		}
+		else {
+			assertTrue(htmlFileClass.getName() + " should not have aspect in its subtitle",
+					classMissing.contains("public abstract aspect <B>ClassA</B><DT>extends java.lang.Object<DT>"));
+		}
     }
     
     /**
 		
 		// ensure that the file is entitled "Aspect PkgVisibleClass.NestedAspect" rather
 		// than "Class PkgVisibleClass.NestedAspect"
-		String[] strings = { "Aspect PkgVisibleClass.NestedAspect",
-				"<PRE>static aspect <B>PkgVisibleClass.NestedAspect</B><DT>extends java.lang.Object</DL>",
-				"Class PkgVisibleClass.NestedAspect",
-				"<PRE>static class <B>PkgVisibleClass.NestedAspect</B><DT>extends java.lang.Object</DL>"};
-		List missing = AjdocOutputChecker.getMissingStringsInFile(htmlFile,strings);
+		String[] strings = null;
+		if (LangUtil.is18VMOrGreater()) {
+			strings = new String[] { 
+					"Aspect PkgVisibleClass.NestedAspect",
+					"<pre>static aspect <span class=\"typeNameLabel\">PkgVisibleClass.NestedAspect</span>",
+					"Class PkgVisibleClass.NestedAspect",
+					"<pre>static class <span class=\"typeNameLabel\">PkgVisibleClass.NestedAspect</span>"};
+		}
+		else {
+			strings = new String[] { 
+					"Aspect PkgVisibleClass.NestedAspect",
+					"<PRE>static aspect <B>PkgVisibleClass.NestedAspect</B><DT>extends java.lang.Object</DL>",
+					"Class PkgVisibleClass.NestedAspect",
+					"<PRE>static class <B>PkgVisibleClass.NestedAspect</B><DT>extends java.lang.Object</DL>"};
+		}
+		List<String> missing = AjdocOutputChecker.getMissingStringsInFile(htmlFile,strings);
 		assertEquals("There should be 2 missing strings",2,missing.size());
 		assertTrue(htmlFile.getName() + " should not have Class as it's title",missing.contains("Class PkgVisibleClass.NestedAspect"));
-		assertTrue(htmlFile.getName() + " should not have class in its subtitle",missing.contains("<PRE>static class <B>PkgVisibleClass.NestedAspect</B><DT>extends java.lang.Object</DL>"));
-		
+		if (LangUtil.is18VMOrGreater()) {
+			assertTrue(htmlFile.getName() + " should not have class in its subtitle",
+					missing.contains("<pre>static class <span class=\"typeNameLabel\">PkgVisibleClass.NestedAspect</span>"));
+		}
+		else {
+			assertTrue(htmlFile.getName() + " should not have class in its subtitle",
+					missing.contains("<PRE>static class <B>PkgVisibleClass.NestedAspect</B><DT>extends java.lang.Object</DL>"));
+		}
 		// get the html file for the enclosing class
         File htmlFileClass = new File(getAbsolutePathOutdir() + "/PkgVisibleClass.html");
 		if (!htmlFileClass.exists()) {
         
 		// ensure that the file is entitled "Class PkgVisibleClass" and
 		// has not been changed to "Aspect PkgVisibleClass"
-		String[] classStrings = { "Class PkgVisibleClass</H2>",
-				"class <B>PkgVisibleClass</B><DT>extends java.lang.Object</DL>",
-				"Aspect PkgVisibleClass</H2>",
-				"aspect <B>PkgVisibleClass</B><DT>extends java.lang.Object<DT>"};
-		List classMissing = AjdocOutputChecker.getMissingStringsInFile(htmlFileClass,classStrings);
+		String[] classStrings = null;
+		if (LangUtil.is18VMOrGreater()) {
+			classStrings = new String[] {
+				"Class PkgVisibleClass</h2>",
+				"<pre>class <span class=\"typeNameLabel\">PkgVisibleClass</span>",
+				"Aspect PkgVisibleClass</h2>",
+				"<pre>aspect <span class=\"typeNameLabel\">PkgVisibleClass</span>"};
+		}
+		else {
+			classStrings = new String[] {
+					"Class PkgVisibleClass</H2>",
+					"class <B>PkgVisibleClass</B><DT>extends java.lang.Object</DL>",
+					"Aspect PkgVisibleClass</H2>",
+					"aspect <B>PkgVisibleClass</B><DT>extends java.lang.Object<DT>"};
+		}
+		List<String> classMissing = AjdocOutputChecker.getMissingStringsInFile(htmlFileClass,classStrings);
 		assertEquals("There should be 2 missing strings",2,classMissing.size());
-		assertTrue(htmlFileClass.getName() + " should not have Aspect as it's title",classMissing.contains("Aspect PkgVisibleClass</H2>"));
-		assertTrue(htmlFileClass.getName() + " should not have aspect in its subtitle",classMissing.contains("aspect <B>PkgVisibleClass</B><DT>extends java.lang.Object<DT>"));
+		if (LangUtil.is18VMOrGreater()) {
+			assertTrue(htmlFileClass.getName() + " should not have Aspect as it's title",
+					classMissing.contains("Aspect PkgVisibleClass</h2>"));
+			assertTrue(htmlFileClass.getName() + " should not have aspect in its subtitle",
+					classMissing.contains("<pre>aspect <span class=\"typeNameLabel\">PkgVisibleClass</span>"));
+		}
+		else {
+			assertTrue(htmlFileClass.getName() + " should not have Aspect as it's title",classMissing.contains("Aspect PkgVisibleClass</H2>"));
+			assertTrue(htmlFileClass.getName() + " should not have aspect in its subtitle",classMissing.contains("aspect <B>PkgVisibleClass</B><DT>extends java.lang.Object<DT>"));
+		}
 	}
 
 	/**
 		}
 		// ensure that the file is entitled "Aspect ClassWithNestedAspect.NestedAspect" 
 		// rather than "Class ClassWithNestedAspect.NestedAspect"
-		String[] strings = { "Aspect ClassWithNestedAspect.NestedAspect",
-				"<PRE>static aspect <B>ClassWithNestedAspect.NestedAspect</B><DT>extends java.lang.Object</DL>",
+		String[] strings = null;
+		if (LangUtil.is18VMOrGreater()) {
+			strings = new String [] {
+				"Aspect ClassWithNestedAspect.NestedAspect",
+				"<pre>static aspect <span class=\"typeNameLabel\">ClassWithNestedAspect.NestedAspect</span>",
 				"Class ClassWithNestedAspect.NestedAspect",
-				"<PRE>static class <B>ClassWithNestedAspect.NestedAspect</B><DT>extends java.lang.Object</DL>"};
-		List missing = AjdocOutputChecker.getMissingStringsInFile(htmlFile,strings);
+				"<pre>static class <span class=\"typeNameLabel\">ClassWithNestedAspect.NestedAspect</span>"};
+		}
+		else {
+			strings = new String [] {
+					"Aspect ClassWithNestedAspect.NestedAspect",
+					"<PRE>static a;spect <B>ClassWithNestedAspect.NestedAspect</B><DT>extends java.lang.Object</DL>",
+					"Class ClassWithNestedAspect.NestedAspect",
+					"<PRE>static class <B>ClassWithNestedAspect.NestedAspect</B><DT>extends java.lang.Object</DL>"};			
+		}
+		List<String> missing = AjdocOutputChecker.getMissingStringsInFile(htmlFile,strings);
 		assertEquals("There should be 2 missing strings",2,missing.size());
 		assertTrue(htmlFile.getName() + " should not have Class as it's title",missing.contains("Class ClassWithNestedAspect.NestedAspect"));
-		assertTrue(htmlFile.getName() + " should not have class in its subtitle",missing.contains("<PRE>static class <B>ClassWithNestedAspect.NestedAspect</B><DT>extends java.lang.Object</DL>"));
+		if (LangUtil.is18VMOrGreater()) {
+			assertTrue(htmlFile.getName() + " should not have class in its subtitle",
+					missing.contains("<pre>static class <span class=\"typeNameLabel\">ClassWithNestedAspect.NestedAspect</span>"));
+		}
+		else {
+			assertTrue(htmlFile.getName() + " should not have class in its subtitle",missing.contains("<PRE>static class <B>ClassWithNestedAspect.NestedAspect</B><DT>extends java.lang.Object</DL>"));
+		}
 		
 		// get the html file for the enclosing class
         File htmlFileClass = new File(getAbsolutePathOutdir() + "/pkg/ClassWithNestedAspect.html");
         
 		// ensure that the file is entitled "Class ClassWithNestedAspect" and
 		// has not been changed to "Aspect ClassWithNestedAspect"
-		String[] classStrings = { "Class ClassWithNestedAspect</H2>",
-				"public class <B>ClassWithNestedAspect</B><DT>extends java.lang.Object</DL>",
-				"Aspect ClassWithNestedAspect</H2>",
-				"public aspect <B>ClassWithNestedAspect</B><DT>extends java.lang.Object</DL>"};
-		List classMissing = AjdocOutputChecker.getMissingStringsInFile(htmlFileClass,classStrings);
+		String[] classStrings = null;
+		if (LangUtil.is18VMOrGreater()) {
+			classStrings = new String[] { 
+				"Class ClassWithNestedAspect</h2>",
+				"public class <span class=\"typeNameLabel\">ClassWithNestedAspect</span>",
+				"Aspect ClassWithNestedAspect</h2>",
+				"public aspect <span class=\"typeNameLabel\">ClassWithNestedAspect</span>"};
+		}
+		else {
+			classStrings = new String[] { 
+					"Class ClassWithNestedAspect</H2>",
+					"public class <B>ClassWithNestedAspect</B><DT>extends java.lang.Object</DL>",
+					"Aspect ClassWithNestedAspect</H2>",
+					"public aspect <B>ClassWithNestedAspect</B><DT>extends java.lang.Object</DL>"};
+		}
+		List<String> classMissing = AjdocOutputChecker.getMissingStringsInFile(htmlFileClass,classStrings);
 		assertEquals("There should be 2 missing strings",2,classMissing.size());
-		assertTrue(htmlFileClass.getName() + " should not have Aspect as it's title",
-				classMissing.contains("Aspect ClassWithNestedAspect</H2>"));
-		assertTrue(htmlFileClass.getName() + " should not have aspect in its subtitle",
-				classMissing.contains("public aspect <B>ClassWithNestedAspect</B><DT>extends java.lang.Object</DL>"));
-
+		if (LangUtil.is18VMOrGreater()) {
+			assertTrue(htmlFileClass.getName() + " should not have Aspect as it's title",
+					classMissing.contains("Aspect ClassWithNestedAspect</h2>"));
+			assertTrue(htmlFileClass.getName() + " should not have aspect in its subtitle",
+					classMissing.contains("public aspect <span class=\"typeNameLabel\">ClassWithNestedAspect</span>"));
+		}
+		else {
+			assertTrue(htmlFileClass.getName() + " should not have Aspect as it's title",
+					classMissing.contains("Aspect ClassWithNestedAspect</H2>"));
+			assertTrue(htmlFileClass.getName() + " should not have aspect in its subtitle",
+					classMissing.contains("public aspect <B>ClassWithNestedAspect</B><DT>extends java.lang.Object</DL>"));
+		}
 	}
 	
 	/**

aspectj5rt/java5-src/org/aspectj/lang/annotation/RequiredTypes.java

+/* *******************************************************************
+ * Copyright (c) 2014 Contributors.
+ * All rights reserved. 
+ * This program and the accompanying materials are made available 
+ * under the terms of the Eclipse Public License v1.0 
+ * which accompanies this distribution and is available at 
+ * http://eclipse.org/legal/epl-v10.html 
+ * ******************************************************************/
+package org.aspectj.lang.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Can be specified on an aspect to ensure that particular types must be accessible before
+ * the aspect will be 'activated'. The array value should be a list of fully qualified
+ * type names as strings, for example "com.foo.Bar". Useful in an aspect library that
+ * includes a number of aspects, only a few of which should ever be active depending
+ * upon what is on the classpath.
+ * 
+ * @author Andy Clement
+ * @since 1.8.3
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface RequiredTypes {
+  String[] value();
+}

org.aspectj.ajdt.core/src/org/aspectj/ajdt/ajc/BuildArgParser.java

 				if (args.size() > nextArgIndex) {
 					// buildConfig.getAjOptions().put(AjCompilerOptions.OPTION_Inpath, CompilerOptions.PRESERVE);
 
-					List inPath = buildConfig.getInpath();
+					List<File> inPath = buildConfig.getInpath();
 					StringTokenizer st = new StringTokenizer(((ConfigParser.Arg) args.get(nextArgIndex)).getValue(),
 							File.pathSeparator);
 					while (st.hasMoreTokens()) {
 				buildConfig.setMakeReflectable(true);
 			} else if (arg.equals("-sourceroots")) {
 				if (args.size() > nextArgIndex) {
-					List sourceRoots = new ArrayList();
+					List<File> sourceRoots = new ArrayList<File>();
 					StringTokenizer st = new StringTokenizer(((ConfigParser.Arg) args.get(nextArgIndex)).getValue(),
 							File.pathSeparator);
 					while (st.hasMoreTokens()) {

org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/ast/AspectDeclaration.java

 			// For e37 moved the check down to this level
 			return;
 		}
+		if ((binding.tagBits & TagBits.AnnotationResolved) != 0) {
+			// possibly resolution occurred during hasUnsatisfiedDependency()...
+			binding.tagBits = (binding.tagBits & ~TagBits.AnnotationResolved);			
+		}
 		Annotation atAspectAnnotation = AtAspectJAnnotationFactory.createAspectAnnotation(perClause.toDeclarationString(),
 				declarationSourceStart);
 		Annotation privilegedAnnotation = null;
 			System.arraycopy(old, 0, annotations, 0, old.length);
 			System.arraycopy(toAdd, 0, annotations, old.length, toAdd.length);
 		}
+		TypeDeclaration.resolveAnnotations(staticInitializerScope, annotations, binding);
 	}
 
 	public void generateCode(ClassFile enclosingClassFile) {

org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseSourceType.java

 	 */
 	public AnnotationAJ[] getAnnotations() {
 		int declarationAnnoCount = (declaration.annotations == null ? 0 : declaration.annotations.length);
-		if (annotations != null && annotations.length==declarationAnnoCount) {
+		if (annotations != null && annotations.length == declarationAnnoCount) {
 			return annotations; // only do this once
 		}
 		if (!annotationsFullyResolved || annotations.length!=declarationAnnoCount) {
 		}
 		return annotations;
 	}
+	
+	public boolean hasAnnotations() {
+		return (declaration.annotations != null && declaration.annotations.length != 0);
+	}
 
 	/**
 	 * Convert one eclipse annotation into an AnnotationX object containing an AnnotationAJ object.

org.aspectj.ajdt.core/testsrc/org/aspectj/tools/ajc/AjcTestCase.java

 		private String text;
 		private String sourceFileName;
 		private ISourceLocation[] seeAlsos;
+		public boolean careAboutOtherMessages = true;
 
 		/**
 		 * Create a message that will match any compiler message on the given line.
 		public Message(int line, String text) {
 			this.line = line;
 			this.text = text;
+			if (this.text != null && text.startsWith("*")) {
+				// Don't care what other messages are around
+				this.careAboutOtherMessages = false;
+				this.text = this.text.substring(1);
+			}
 		}
 
 		/**
 				this.sourceFileName = srcFileName.toString();
 			}
 			this.text = text;
+			if (this.text != null && text.startsWith("*")) {
+				// Don't care what other messages are around
+				this.careAboutOtherMessages = false;
+				this.text = this.text.substring(1);
+			}
 			this.seeAlsos = seeAlso;
 		}
 
 		 */
 		public Message(String text) {
 			this.text = text;
+			if (this.text != null && text.startsWith("*")) {
+				// Don't care what other messages are around
+				this.careAboutOtherMessages = false;
+				this.text = this.text.substring(1);
+			}
 		}
 
 		/**
 				Collections.EMPTY_LIST, Collections.EMPTY_LIST);
 
 		boolean ignoreInfos = true;
-		public List fails;
-		public List infos;
-		public List warnings;
-		public List errors;
-		public List weaves;
+		public List<AjcTestCase.Message> fails;
+		public List<AjcTestCase.Message> infos;
+		public List<AjcTestCase.Message> warnings;
+		public List<AjcTestCase.Message> errors;
+		public List<AjcTestCase.Message> weaves;
 
 		/**
 		 * Set to true to enable or disable comparison of information messages.
 		 * @param errors The set of error messages to test for - can pass null to indicate empty set.
 		 * @param fails The set of fail or abort messages to test for - can pass null to indicate empty set.
 		 */
-		public MessageSpec(List infos, List warnings, List errors, List fails, List weaves) {
+		public MessageSpec(List<AjcTestCase.Message> infos, List<AjcTestCase.Message> warnings, 
+				List<AjcTestCase.Message> errors, List<AjcTestCase.Message> fails, List<AjcTestCase.Message> weaves) {
 			if (infos != null) {
 				this.infos = infos;
 				ignoreInfos = false;
 			} else {
-				this.infos = Collections.EMPTY_LIST;
+				this.infos = Collections.emptyList();
 			}
-			this.warnings = ((warnings == null) ? Collections.EMPTY_LIST : warnings);
-			this.errors = ((errors == null) ? Collections.EMPTY_LIST : errors);
-			this.fails = ((fails == null) ? Collections.EMPTY_LIST : fails);
-			this.weaves = ((weaves == null) ? Collections.EMPTY_LIST : weaves);
+			this.warnings = ((warnings == null) ? Collections.<AjcTestCase.Message>emptyList() : warnings);
+			this.errors = ((errors == null) ? Collections.<AjcTestCase.Message>emptyList() : errors);
+			this.fails = ((fails == null) ? Collections.<AjcTestCase.Message>emptyList() : fails);
+			this.weaves = ((weaves == null) ? Collections.<AjcTestCase.Message>emptyList() : weaves);
 		}
 
 		/**
 		 * Create a message specification to test a CompilationResult for a given set of info, warning, and error messages. The
 		 * presence of any fail or abort messages in a CompilationResult will be a test failure.
 		 */
-		public MessageSpec(List infos, List warnings, List errors) {
+		public MessageSpec(List<AjcTestCase.Message> infos, List<AjcTestCase.Message> warnings, List<AjcTestCase.Message> errors) {
 			this(infos, warnings, errors, null, null);
 		}
 
 		 * Create a message specification to test a CompilationResult for a given set of warning, and error messages. The presence
 		 * of any fail or abort messages in a CompilationResult will be a test failure. Informational messages will be ignored.
 		 */
-		public MessageSpec(List warnings, List errors) {
+		public MessageSpec(List<AjcTestCase.Message> warnings, List<AjcTestCase.Message> errors) {
 			this(null, warnings, errors, null, null);
 		}
 	}
 	public void assertMessages(CompilationResult result, String message, MessageSpec expected) {
 		if (result == null)
 			fail("Attempt to compare null compilation results against expected.");
-		List missingFails = copyAll(expected.fails);
-		List missingInfos = copyAll(expected.infos);
-		List missingWarnings = copyAll(expected.warnings);
-		List missingErrors = copyAll(expected.errors);
-		List missingWeaves = copyAll(expected.weaves);
+		List<AjcTestCase.Message> missingFails = copyAll(expected.fails);
+		List<AjcTestCase.Message> missingInfos = copyAll(expected.infos);
+		List<AjcTestCase.Message> missingWarnings = copyAll(expected.warnings);
+		List<AjcTestCase.Message> missingErrors = copyAll(expected.errors);
+		List<AjcTestCase.Message> missingWeaves = copyAll(expected.weaves);
 		List<IMessage> extraFails = copyAll(result.getFailMessages());
 		List<IMessage> extraInfos = copyAll(result.getInfoMessages());
 		List<IMessage> extraWarnings = copyAll(result.getWarningMessages());
 		return ret;
 	}
 
-	private List copyAll(List in) {
+	private <T> List<T> copyAll(List<T> in) {
 		if (in == Collections.EMPTY_LIST)
 			return in;
 
-		List out = new ArrayList();
-		for (Iterator iter = in.iterator(); iter.hasNext();) {
+		List<T> out = new ArrayList<T>();
+		for (Iterator<T> iter = in.iterator(); iter.hasNext();) {
 			out.add(iter.next());
 		}
 		return out;
 	 * @param missingElements the missing messages, when passed in must contain all of the expected messages
 	 * @param extraElements the additional messages, when passed in must contain all of the actual messages
 	 */
-	private void compare(List expected, List actual, List missingElements, List extraElements) {
-		for (Iterator expectedIter = expected.iterator(); expectedIter.hasNext();) {
-			Message expectedMessage = (Message) expectedIter.next();
-			for (Iterator actualIter = actual.iterator(); actualIter.hasNext();) {
-				IMessage actualMessage = (IMessage) actualIter.next();
+	private void compare(List<AjcTestCase.Message> expected, List<IMessage> actual, List<AjcTestCase.Message> missingElements, List<IMessage> extraElements) {
+		for (Message expectedMessage: expected) {
+			for (IMessage actualMessage: actual) {
 				if (expectedMessage.matches(actualMessage)) {
-					missingElements.remove(expectedMessage);
-					extraElements.remove(actualMessage);
+					if (expectedMessage.careAboutOtherMessages) {
+						missingElements.remove(expectedMessage);
+						extraElements.remove(actualMessage);
+					}
+					else {
+						missingElements.clear();
+						extraElements.clear();
+					}
 				}
 			}
 		}
 	}
 
-	private void addMissing(StringBuffer buff, String type, List messages) {
+	private void addMissing(StringBuffer buff, String type, List<AjcTestCase.Message> messages) {
 		if (!messages.isEmpty()) {
 			buff.append("Missing expected ");
 			buff.append(type);
 			buff.append(" messages:\n");
-			for (Iterator iter = messages.iterator(); iter.hasNext();) {
+			for (Iterator<AjcTestCase.Message> iter = messages.iterator(); iter.hasNext();) {
 				buff.append("\t");
 				buff.append(iter.next().toString());
 				buff.append("\n");

org.aspectj.matcher/src/org/aspectj/weaver/BCException.java

 /**
  * Exception to use inside the bcweaver.
  */
+@SuppressWarnings("serial")
 public class BCException extends RuntimeException {
 	Throwable thrown;
 

org.aspectj.matcher/src/org/aspectj/weaver/BoundedReferenceTypeDelegate.java

 	public AnnotationAJ[] getAnnotations() {
 		return resolvedTypeX.getAnnotations();
 	}
+	
+	public boolean hasAnnotations() {
+		return resolvedTypeX.hasAnnotations();
+	}
 
 	public ResolvedType[] getAnnotationTypes() {
 		return resolvedTypeX.getAnnotationTypes();

org.aspectj.matcher/src/org/aspectj/weaver/GeneratedReferenceTypeDelegate.java

 	public AnnotationAJ[] getAnnotations() {
 		throw new UnsupportedOperationException("Not supported for GeneratedReferenceTypeDelegate");
 	}
+	
+	public boolean hasAnnotations() {
+		throw new UnsupportedOperationException("Not supported for GeneratedReferenceTypeDelegate");
+	}
 
 	public ResolvedType[] getAnnotationTypes() {
 		throw new UnsupportedOperationException("Not supported for GeneratedReferenceTypeDelegate");

org.aspectj.matcher/src/org/aspectj/weaver/ReferenceType.java

 		return getDelegate().getAnnotations();
 	}
 
+	@Override
+	public boolean hasAnnotations() {
+		return getDelegate().hasAnnotations();
+	}
+
 	@Override
 	public void addAnnotation(AnnotationAJ annotationX) {
 		if (annotations == null) {

org.aspectj.matcher/src/org/aspectj/weaver/ReferenceTypeDelegate.java

 
 	public boolean hasBeenWoven();
 
+	public boolean hasAnnotations();
+
 }

org.aspectj.matcher/src/org/aspectj/weaver/ResolvedType.java

 	public AnnotationAJ[] getAnnotations() {
 		throw new RuntimeException("ResolvedType.getAnnotations() should never be called");
 	}
+	
+	public boolean hasAnnotations() {
+		throw new RuntimeException("ResolvedType.getAnnotations() should never be called");
+	}
+
 
 	/**
 	 * Note: Only overridden by ReferenceType subtype

org.aspectj.matcher/src/org/aspectj/weaver/WeaverStateInfo.java

 		case UNTOUCHED:
 			throw new RuntimeException("unexpected UNWOVEN");
 		case WOVEN:
-			return new WeaverStateInfo(Collections.EMPTY_LIST, true, isReweavable, isReweavableCompressed, isReweavableDiff);
+			return new WeaverStateInfo(Collections.<Entry>emptyList(), true, isReweavable, isReweavableCompressed, isReweavableDiff);
 		case EXTENDED:
 			boolean isCompressed = false;
 			if (s.isAtLeast169()) {
 			}
 
 			int n = s.readShort();
-			List l = new ArrayList();
+			List<Entry> l = new ArrayList<Entry>();
 			for (int i = 0; i < n; i++) {
 				// conditional on version
 				UnresolvedType aspectType = null;

org.aspectj.matcher/src/org/aspectj/weaver/patterns/ArgsPointcut.java

 	 * @see org.aspectj.weaver.patterns.NameBindingPointcut#getBindingTypePatterns()
 	 */
 	public List getBindingTypePatterns() {
-		List l = new ArrayList();
+		List<BindingTypePattern> l = new ArrayList<BindingTypePattern>();
 		TypePattern[] pats = arguments.getTypePatterns();
 		for (int i = 0; i < pats.length; i++) {
 			if (pats[i] instanceof BindingTypePattern) {
-				l.add(pats[i]);
+				l.add((BindingTypePattern)pats[i]);
 			}
 		}
 		return l;

org.aspectj.matcher/src/org/aspectj/weaver/patterns/BasicTokenSource.java

 		char[] chars = input.toCharArray();
 		
 		int i = 0;
-		List tokens = new ArrayList();
+		List<BasicToken> tokens = new ArrayList<BasicToken>();
 		
 		while (i < chars.length) {
 			char ch = chars[i++];			

org.aspectj.matcher/src/org/aspectj/weaver/reflect/ReflectionBasedReferenceTypeDelegate.java

 		// no annotations in Java 1.4
 		return AnnotationAJ.EMPTY_ARRAY;
 	}
+	
+	public boolean hasAnnotations() {
+		return false;
+	}
 
 	/*
 	 * (non-Javadoc)

org.aspectj.matcher/testsrc/org/aspectj/matcher/tools/CommonAdvancedPointcutExpressionTests.java

 		return null;
 	}
 
+	@SuppressWarnings("unused")
 	private void checkAlwaysMatches(String pointcutExpression, String type, String methodName, String methodSignature) {
 		StandardPointcutExpression ex = pointcutParser.parsePointcutExpression(pointcutExpression);
 		assertNotNull(ex);
 		assertTrue(b);
 	}
 
+	@SuppressWarnings("unused")
 	private void checkNeverMatches(String pointcutExpression, String type, String methodName, String methodSignature) {
 		StandardPointcutExpression ex = pointcutParser.parsePointcutExpression(pointcutExpression);
 		assertNotNull(ex);

org.aspectj.matcher/testsrc/org/aspectj/weaver/CommonWorldTests.java

 	}
 
 	protected void mungersTest(ResolvedType ty, ShadowMunger[] x) {
-		List l = (List) ty.getDeclaredShadowMungers();
+		List<ShadowMunger> l = ty.getDeclaredShadowMungers();
 		ShadowMunger[] array = (ShadowMunger[]) l.toArray(new ShadowMunger[l.size()]);
 		TestUtil.assertSetEquals(ty + " mungers:", x, array);
 	}

org.aspectj.matcher/testsrc/org/aspectj/weaver/TestUtils.java

 	public static String[] parseIds(String str) {
 		if (str.length() == 0)
 			return ZERO_STRINGS;
-		List l = new ArrayList();
+		List<String> l = new ArrayList<String>();
 		int start = 0;
 		while (true) {
 			int i = str.indexOf(',', start);

org.aspectj.matcher/testsrc/org/aspectj/weaver/patterns/ArgsTestCase.java

 		assertFalse("no match expected", sMatch.matchesJoinPoint(thisOjb, targetObj, args).matches());
 	}
 
+	@SuppressWarnings("unused")
 	private static class A {
 		public void anInt(int i) {
 		}
 
 	}
 
+	@SuppressWarnings("unused")
 	private static class B extends A {
 		public void x(A a) {
 		}
 		}
 	}
 
+	@SuppressWarnings("unused")
 	private static class C {
 		public void z(A a, C c) {
 		}

org.aspectj.matcher/testsrc/org/aspectj/weaver/patterns/ModifiersPatternTestCase.java

 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.lang.reflect.Modifier;
-import java.util.ArrayList;
-import java.util.List;
 
 import org.aspectj.weaver.CompressingDataOutputStream;
-import org.aspectj.weaver.ConstantPoolReader;
-import org.aspectj.weaver.ConstantPoolWriter;
 import org.aspectj.weaver.VersionedDataInputStream;
 import org.aspectj.weaver.World;
 import org.aspectj.weaver.reflect.ReflectionWorld;

testing/newsrc/org/aspectj/testing/CompileSpec.java

 	}
 	
 	protected AjcTestCase.MessageSpec buildMessageSpec() {
-		List infos = null;
-		List warnings = new ArrayList();
-		List errors = new ArrayList();
-		List fails = new ArrayList();
-		List weaveInfos = new ArrayList();
+		List<AjcTestCase.Message> infos = null;
+		List<AjcTestCase.Message> warnings = new ArrayList<AjcTestCase.Message>();
+		List<AjcTestCase.Message> errors = new ArrayList<AjcTestCase.Message>();
+		List<AjcTestCase.Message> fails = new ArrayList<AjcTestCase.Message>();
+		List<AjcTestCase.Message> weaveInfos = new ArrayList<AjcTestCase.Message>();
 		for (Iterator iter = expected.iterator(); iter.hasNext();) {
 			ExpectedMessageSpec exMsg = (ExpectedMessageSpec) iter.next();
 			String kind = exMsg.getKind();
 			if (kind.equals("info")) {
-				if (infos == null) infos = new ArrayList();
+				if (infos == null) infos = new ArrayList<AjcTestCase.Message>();
 				infos.add(exMsg.toMessage());
 			} else if (kind.equals("warning")) {
 				warnings.add(exMsg.toMessage());

tests/bugs183/436653/A.java

+public class A {}

tests/bugs183/436653/AnnoX.java

+import org.aspectj.lang.annotation.*;
+
+@RequiredTypes("A")
+@Aspect
+class X {
+  @Before("execution(* Code.*(..))")
+  public void m() {
+    System.out.println("x");
+  }
+}

tests/bugs183/436653/B.java

+public class B {}

tests/bugs183/436653/Code.java

+public class Code {
+  public void m() {}
+}

tests/bugs183/436653/Runner.java

+public class Runner {
+  public static void main(String []argv) {
+    new Code().m();
+  }
+}
+
+class Code {
+  public void m() {
+    System.out.println("Code.m() running");
+  }
+}

tests/bugs183/436653/X.java

+import org.aspectj.lang.annotation.*;
+
+@RequiredTypes("A")
+aspect X {
+  before(): execution(* Code.*(..)) {System.out.println("x");}
+}

tests/bugs183/436653/XA.java

+import org.aspectj.lang.annotation.*;
+
+aspect XA {
+  @SuppressAjWarnings("adviceDidNotMatch")
+  before(): execution(* A.*(..)) {}
+}
+

tests/bugs183/436653/XA2.java

+import org.aspectj.lang.annotation.*;
+
+// Aspect deactivated if A is missing
+@RequiredTypes("A")
+aspect XA2 {
+  @SuppressAjWarnings("adviceDidNotMatch")
+  before(): execution(* A.*(..)) {}
+}
+

tests/bugs183/436653/XA3.java

+import org.aspectj.lang.annotation.*;
+
+// Aspect deactivated if A or B is missing (although aspect only really needs A)
+@RequiredTypes({"A","B"})
+aspect XA2 {
+  @SuppressAjWarnings("adviceDidNotMatch")
+  before(): execution(* A.*(..)) {}
+}
+

tests/bugs183/436653/XB.java

+import org.aspectj.lang.annotation.*;
+
+aspect XB {
+  before(): execution(* B.*(..)) {}
+}
+

tests/bugs183/436653/XCode.java

+import org.aspectj.lang.annotation.*;
+
+aspect XCode {
+  @SuppressAjWarnings("adviceDidNotMatch")
+  before(): execution(* Cod*.*(..)) {}
+}
+

tests/bugs183/436653/aop.xml

+<aspectj>
+<aspects>
+<aspect name="X"/>
+</aspects>
+<weaver options="-verbose"/>
+</aspectj>
+

tests/bugs183/436653/aop2.xml

+<aspectj>
+<aspects>
+<aspect name="X"/>
+</aspects>
+<weaver options="-verbose"/>
+</aspectj>
+

tests/java5/annotations/itds/AtItd3.aj

       Annotation aa = m.getAnnotation(Ann.class);
       System.err.println("Ann.class retrieved is: "+aa);
 
-      if (!aa.toString().equals("@Ann(id=goodbye, anInt=4)")) 
+      if (!aa.toString().equals("@Ann(id=goodbye, anInt=4)")) // < Java8 order
+          if (!aa.toString().equals("@Ann(anInt=4, id=goodbye)")) // Java8 order
         throw new RuntimeException("Incorrect output, expected:"+
           "@Ann(id=goodbye, anInt=4) but got "+aa.toString());
  

tests/java5/ataspectj/ajc-ant.xml

 
     <target name="compile:javac">
         <!-- compile only javac compilable stuff, exclude the one that needs other dependencies -->
-        <javac target="1.5" destdir="${aj.sandbox}" classpathref="aj.path"
+        <javac source="1.5" target="1.5" destdir="${aj.sandbox}" classpathref="aj.path"
             srcdir="${basedir}"
             includes="ataspectj/*"
             excludes="ataspectj/UnweavableTest.java"
 
     <target name="ltw.Aspect2MainTest">
         <!-- javac Aspect2 -->
-        <javac target="1.5" destdir="${aj.sandbox}" classpathref="aj.path"
+        <javac source="1.5" target="1.5" destdir="${aj.sandbox}" classpathref="aj.path"
             srcdir="${basedir}"
             includes="ataspectj/ltwreweavable/Aspect2.java"
             debug="true">
     </target>
 
     <target name="ltw.Unweavable">
-        <javac target="1.5"  destdir="${aj.sandbox}"
+        <javac source="1.5" target="1.5"  destdir="${aj.sandbox}"
             srcdir="${basedir}"
             includes="ataspectj/UnweavableTest.java, ataspectj/TestHelper.java"
             debug="true">
 
     <target name="ltw.Decp2">
         <!-- javac compile the 2nd aspect -->
-        <javac target="1.5"  destdir="${aj.sandbox}"
+        <javac source="1.5" target="1.5"  destdir="${aj.sandbox}"
             srcdir="${basedir}"
             includes="ataspectj/DeclareParentsImplementsReweavableTestAspect.java"
             debug="true">

tests/java5/ataspectj/annotationGen/SA.aj

+import org.aspectj.lang.annotation.Aspect;
+import java.lang.annotation.*;
+
+public aspect SA {
+	
+	public static void main(String[] args) {
+		Annotation[] annotations = SA.class.getAnnotations();
+		if (annotations.length != 1) throw new RuntimeException("Should have one annotation but has "+annotations.length);
+		Aspect aspectAnnotation = (Aspect) annotations[0];
+System.out.println(aspectAnnotation);
+		if (!aspectAnnotation.value().equals("")) throw new RuntimeException("value should be empty");
+	}
+	
+}

tests/java5/ataspectj/annotationGen/SimpleAspect.aj

 	
 	public static void main(String[] args) {
 		Annotation[] annotations = SimpleAspect.class.getAnnotations();
-		if (annotations.length != 1) throw new RuntimeException("Should have one annotation");
+		if (annotations.length != 1) throw new RuntimeException("Should have one annotation but has "+annotations.length);
 		Aspect aspectAnnotation = (Aspect) annotations[0];
 		if (!aspectAnnotation.value().equals("")) throw new RuntimeException("value should be empty");
 	}
 	
-}
+}

tests/src/org/aspectj/systemtest/ajc150/ltw/LTWTests.java

 		runTest("JDK14 LTW with XML");  		
   	}
   	
-  	public void testJ14LTWWithASPECTPATH() {  	
-		runTest("JDK14 LTW with ASPECTPATH");  		
-  	}
+//  	public void testJ14LTWWithASPECTPATH() {  	
+//		runTest("JDK14 LTW with ASPECTPATH");  		
+//  	}
   	
 
     //public void testDiscardingWovenTypes() { 

tests/src/org/aspectj/systemtest/ajc170/ajc170.xml

        <stdout>
            <line text="Annotations on field1? true"/>
            <line text="Annotation count is 4"/>
-           <line text="@AnnoBoolean(zzz=false, value=true)"/>
+           <line text="@AnnoBoolean(value=true, zzz=false)"/>
            <line text="@AnnoClass(value=class java.lang.Integer, ccc=class java.lang.String)"/>
-           <line text="@AnnoLong(jjj=111, value=999)"/>
-           <line text="@AnnoString(sss=xyz, value=set from xml)"/>
+           <line text="@AnnoLong(value=999, jjj=111)"/>
+           <line text="@AnnoString(value=set from xml, sss=xyz)"/>
            <line text="Annotations on field2? true"/>
            <line text="Annotation count is 1"/>
            <line text="@AnnoClass(value=class java.lang.String, ccc=class java.lang.String)"/>
            <line text="Annotations on field1? true"/>
            <line text="Annotation count is 4"/>
            <line text="@AnnoChar(value=z, ccc=a)"/>
-           <line text="@AnnoDouble(ddd=3.0, value=99.0)"/>
-           <line text="@AnnoFloat(fff=4.0, value=6.0)"/>
-           <line text="@AnnoShort(sss=3, value=8)"/>
+           <line text="@AnnoDouble(value=99.0, ddd=3.0)"/>
+           <line text="@AnnoFloat(value=6.0, fff=4.0)"/>
+           <line text="@AnnoShort(value=8, sss=3)"/>
            <line text="Annotations on field2? true"/>
            <line text="Annotation count is 2"/>
            <line text="@AnnoByte(value=88, bbb=66)"/>
-           <line text="@AnnoInt(value=99, iii=111)"/>
+           <line text="@AnnoInt(iii=111, value=99)"/>
        </stdout>
      </run>
    </ajc-test>

tests/src/org/aspectj/systemtest/ajc173/ajc173.xml

 		</compile>
 		<run class="Hello">
 		<stdout>
-		<line text="@MyAnnotation(dummy2=korte, dummy1=)"/>
+		<line text="@MyAnnotation(dummy1=, dummy2=korte)"/>
 		</stdout>
 		</run>
 	</ajc-test>

tests/src/org/aspectj/systemtest/ajc183/Ajc183Tests.java

  */
 public class Ajc183Tests extends org.aspectj.testing.XMLBasedAjcTestCase {
 
+	public void testSuppressTypeNotFound_436653() {
+		runTest("suppress type not found");
+	}
+
+	public void testSuppressTypeNotFound_436653_2() {
+		runTest("suppress type not found 2");
+	}
+
+	public void testSuppressTypeNotFound_436653_3() {
+		runTest("suppress type not found 3");
+	}
+	
+	public void testSuppressTypeNotFound_436653_4() {
+		runTest("suppress type not found 4");
+	}
+
+	public void testSuppressTypeNotFound_436653_5() {
+		runTest("suppress type not found 5");
+	}
+
+	public void testSuppressTypeNotFound_436653_6() {
+		runTest("suppress type not found 6");
+	}
+
+	public void testSuppressTypeNotFound_436653_7() {
+		runTest("suppress type not found 7");
+	}
+	
+	public void testSuppressTypeNotFound_436653_8() {
+		runTest("suppress type not found 8");
+	}
+	
 	public void testConstantPool_445395_0() {
 		runTest("constant pool 0");
 	}

tests/src/org/aspectj/systemtest/ajc183/ajc183.xml

 
 <suite>
 
+	<ajc-test dir="bugs183/436653" title="suppress type not found 4">
+		<compile options="-1.8 -Xlint:ignore" files="X.java" outjar="aspects.jar"/>
+		<compile options="-1.8" files="Runner.java"/>
+		<run class="Runner" ltw="aop.xml">
+	        <stdout>
+	        <line text="Code.m() running"/>
+	        </stdout>
+	    </run>
+    </ajc-test>
+    
+    <ajc-test dir="bugs183/436653" title="suppress type not found 5">
+		<compile options="-1.8 -Xlint:ignore" files="X.java" outjar="aspects.jar"/>
+		<compile class="-1.8" files="A.java"/>
+		<compile options="-1.8" files="Runner.java"/>
+		<run class="Runner" ltw="aop.xml">
+	        <stdout>
+	        <line text="x"/>
+	        <line text="Code.m() running"/>
+	        </stdout>
+	    </run>
+    </ajc-test>
+    
+    <!-- annotation style aspect, missing type so deactivated -->
+   	<ajc-test dir="bugs183/436653" title="suppress type not found 6">
+		<compile options="-1.8 -Xlint:ignore" files="AnnoX.java" outjar="aspects.jar"/>
+		<compile options="-1.8" files="Runner.java"/>
+		<run class="Runner" ltw="aop2.xml">
+	        <stdout>
+	        <line text="Code.m() running"/>
+	        </stdout>
+	    </run>
+    </ajc-test>
+    
+    <!-- annotation style aspect, type not missing so not deactivated -->
+    <ajc-test dir="bugs183/436653" title="suppress type not found 7">
+		<compile options="-1.8 -Xlint:ignore" files="AnnoX.java A.java" outjar="aspects.jar"/>
+		<compile options="-1.8" files="Runner.java"/>
+		<run class="Runner" ltw="aop2.xml">
+	        <stdout>
+	        <line text="x"/>
+	        <line text="Code.m() running"/>
+	        </stdout>
+	    </run>
+    </ajc-test>
+    
+    <!-- annotation style aspect, type not missing so not deactivated -->
+    <ajc-test dir="bugs183/436653" title="suppress type not found 8">
+		<compile options="-1.8 -Xlint:ignore" files="AnnoX.java A.java" outjar="aspects.jar"/>
+		<compile options="-1.8 -showWeaveInfo" files="Runner.java" aspectpath="aspects.jar">
+			<message kind="weave" text="Join point 'method-execution(void Code.m())' in Type 'Code' (Runner.java:8) advised by before advice from 'X' (aspects.jar!AnnoX.class(from AnnoX.java))"/>
+		</compile>
+		<run class="Runner">
+	        <stdout>
+	        <line text="x"/>
+	        <line text="Code.m() running"/>
+	        </stdout>
+	    </run>
+    </ajc-test>
+
+	<ajc-test dir="bugs183/436653" title="suppress type not found 3">
+		<compile options="-1.8" files="A.java" outjar="typeA.jar"/>
+		<compile options="-1.8" files="B.java" outjar="typeB.jar"/>
+		<!-- adviceDidNotMatch messages are suppressed here -->
+		<compile options="-1.8" files="XA3.java XCode.java" outjar="aspects.jar" classpath="typeA.jar"/>
+		<compile options="-1.8 -verbose" files="Code.java" classpath="typeA.jar" aspectpath="aspects.jar">
+			<!-- '*' is a hint that we care about only this message, not other messages. avoids needing to list them all -->
+			<message kind="info" text="*deactivating aspect 'XA2' as it requires type 'B' which cannot be found on the classpath"/>
+		</compile>
+	</ajc-test>
+	
+	<ajc-test dir="bugs183/436653" title="suppress type not found 2">
+		<compile options="-1.8" files="A.java" outjar="typeA.jar"/>
+		<!-- adviceDidNotMatch messages are suppressed here -->
+		<compile options="-1.8" files="XA2.java XCode.java" outjar="aspects.jar" classpath="typeA.jar"/>
+		<compile options="-1.8" files="Code.java" aspectpath="aspects.jar">
+		</compile>
+	</ajc-test>
+	
+	<ajc-test dir="bugs183/436653" title="suppress type not found">
+		<compile options="-1.8" files="A.java" outjar="typeA.jar"/>
+		<!-- adviceDidNotMatch messages are suppressed here -->
+		<compile options="-1.8" files="XA.java XCode.java" outjar="aspects.jar" classpath="typeA.jar"/>
+		<compile options="-1.8" files="Code.java" aspectpath="aspects.jar">
+		  <message kind="error" text="can't determine modifiers of missing type A"/>
+		</compile>
+	</ajc-test>
+
 	<ajc-test dir="bugs183/445395" title="constant pool 0">
 		<compile options="-1.8" files="Code.java">
 		</compile>

tests/src/org/aspectj/systemtest/incremental/tools/AjdeInteractionTestbed.java

 		File projectBase = new File(sandboxDir, pname);
 		ICompilerConfiguration icc = compiler.getCompilerConfiguration();
 		List currentFiles = icc.getProjectSourceFiles();
-		List filesForCompilation = new ArrayList();
+		List<String> filesForCompilation = new ArrayList<String>();
 		collectUpFiles(projectBase, projectBase, filesForCompilation);
 		boolean changed = false;
 		for (int i = 0; i < filesForCompilation.size(); i++) {

tests/src/org/aspectj/systemtest/incremental/tools/MultiProjTestCompilerConfiguration.java

 	private Set aspectPath = null;
 	private Map sourcePathResources = null;
 	private IOutputLocationManager outputLocationManager = null;
-	private List dependants;
+	private List<String> dependants;
 	private Map javaOptionsMap;
 	private Set<File> inpath;
 	private String encoding = null;
 	private String processor;
 	private String processorPath;
 	private String nonstandardoptions;
-	private List modifiedFiles;
-	private List modifiedDirs;
-	private List projectSourceFiles = new ArrayList();
+	private List<File> modifiedFiles;
+	private List<String> modifiedDirs;
+	private List<String> projectSourceFiles = new ArrayList();
 	private List xmlConfigFiles = new ArrayList();
 	private String projectPath;
 
 		return xmlConfigFiles;
 	}
 
-	public List getProjectSourceFilesChanged() {
+	public List<File> getProjectSourceFilesChanged() {
 		log("ICompilerConfiguration.getProjectSourceFilesChanged()");
 		return modifiedFiles;
 	}
 
 	public void addDependancy(String projectItDependsOn) {
 		if (dependants == null) {
-			dependants = new ArrayList();
+			dependants = new ArrayList<String>();
 		}
 		dependants.add(projectItDependsOn);
 	}
 		this.changed |= ICompilerConfiguration.NONSTANDARDOPTIONS_CHANGED;
 	}
 
-	public void setProjectSourceFiles(List projectSourceFiles) {
+	public void setProjectSourceFiles(List<String> projectSourceFiles) {
 		this.projectSourceFiles = projectSourceFiles;
 		this.changed |= ICompilerConfiguration.PROJECTSOURCEFILES_CHANGED;
 	}
 
-	public void setProjectXmlConfigFiles(List xmlConfigFiles) {
+	public void setProjectXmlConfigFiles(List<String> xmlConfigFiles) {
 		this.xmlConfigFiles = xmlConfigFiles;
 		this.changed |= ICompilerConfiguration.XMLCONFIG_CHANGED;
 	}
 
 	public void addProjectSourceFileChanged(File f) {
 		if (this.modifiedFiles == null) {
-			this.modifiedFiles = new ArrayList();
+			this.modifiedFiles = new ArrayList<File>();
 		}
 		if (f != null) {
 			modifiedFiles.add(f);
 
 	public void addClasspathEntryChanged(String f) {
 		if (this.modifiedDirs == null) {
-			this.modifiedDirs = new ArrayList();
+			this.modifiedDirs = new ArrayList<String>();
 		}
 		if (f != null) {
 			modifiedDirs.add(f);

weaver/src/org/aspectj/weaver/bcel/BcelObjectType.java

 		ensureAnnotationsUnpacked();
 		return annotations;
 	}
+	
+	public boolean hasAnnotations() {
+		ensureAnnotationsUnpacked();
+		return annotations.length != 0;
+	}
 
 	public boolean hasAnnotation(UnresolvedType ofType) {
 		// Due to re-entrancy we may be in the middle of unpacking the annotations already... in which case use this slow

weaver/src/org/aspectj/weaver/bcel/BcelWorld.java

 
 	@Override
 	public boolean hasUnsatisfiedDependency(ResolvedType aspectType) {
+		String aspectName = aspectType.getName();
+
+		if (aspectType.hasAnnotations()) {
+			AnnotationAJ[] annos = aspectType.getAnnotations();
+			for (AnnotationAJ anno: annos) {
+				if (anno.getTypeName().equals("org.aspectj.lang.annotation.RequiredTypes")) {
+					String values = anno.getStringFormOfValue("value"); // Example: "[A,org.foo.Bar]"
+					if (values != null && values.length() > 2) {
+						values = values.substring(1,values.length()-1);
+						StringTokenizer tokenizer = new StringTokenizer(values,",");
+						boolean anythingMissing = false;
+						while (tokenizer.hasMoreElements()) {
+							String requiredTypeName = tokenizer.nextToken();
+							ResolvedType rt = resolve(UnresolvedType.forName(requiredTypeName));
+							if (rt.isMissing()) {
+								if (!getMessageHandler().isIgnoring(IMessage.INFO)) {
+									getMessageHandler().handleMessage(
+											MessageUtil.info("deactivating aspect '" + aspectName + "' as it requires type '"
+													+ requiredTypeName + "' which cannot be found on the classpath"));
+								}
+								anythingMissing = true;
+								if (aspectRequiredTypes == null) {
+									aspectRequiredTypes = new HashMap<String,String>();
+								}
+								// Record that it has an invalid type reference
+								aspectRequiredTypes.put(aspectName,requiredTypeName);
+							}
+						}				
+						if (anythingMissing) {
+							return true;
+						}
+						else {
+							return false;
+						}
+					}
+					else {
+						// no value specified for annotation
+						return false;
+					}
+				}
+			}
+		}
 		if (aspectRequiredTypes == null) {
 			// no aspects require anything, so there can be no unsatisfied dependencies
 			return false;
 		}
-		String aspectName = aspectType.getName();
 		if (!aspectRequiredTypesProcessed.contains(aspectName)) {
 			String requiredTypeName = aspectRequiredTypes.get(aspectName);
 			if (requiredTypeName==null) {
 		if (aspectRequiredTypes == null) {
 			aspectRequiredTypes = new HashMap<String, String>();
 		}
-		aspectRequiredTypes.put(aspectClassName, requiredType);
+		aspectRequiredTypes.put(aspectClassName,requiredType);
 	}
 
 	/**

weaver/testsrc/org/aspectj/weaver/bcel/WorldTestCase.java

 package org.aspectj.weaver.bcel;
 
 import java.lang.reflect.Modifier;
+import java.util.Objects;
+import java.util.function.Consumer;
 
 import org.aspectj.weaver.Advice;
 import org.aspectj.weaver.BcweaverTests;
 
 		modifiersTest(iter, abstractPublic | Modifier.INTERFACE);
 		fieldsTest(iter, ResolvedMember.NONE);
-		methodsTest(iter, new Member[] { MemberImpl.method(iter, 0, "hasNext", "()Z"), MemberImpl.method(iter, 0, "remove", "()V"),
-				MemberImpl.method(iter, 0, "next", "()Ljava/lang/Object;"), });
+		methodsTest(iter, new Member[] { 
+				MemberImpl.method(iter, 0, "hasNext", "()Z"), 
+				MemberImpl.method(iter, 0, "remove", "()V"),
+				MemberImpl.method(iter, 0, "next", "()Ljava/lang/Object;"), 
+				MemberImpl.method(iter, 0, "forEachRemaining", "(Ljava/util/function/Consumer;)V")
+//				default void forEachRemaining(Consumer<? super E> action) {
+//			        Objects.requireNonNull(action);
+//			        while (hasNext())
+//			            action.accept(next());
+//			    }
+				});
 		ResolvedMember remove = iter.lookupMethod(MemberImpl.method(iter, 0, "remove", "()V"));
 		assertNotNull("iterator doesn't have remove", remove);
-		modifiersTest(remove, abstractPublic | Modifier.INTERFACE);
+		modifiersTest(remove, Modifier.PUBLIC | Modifier.INTERFACE); // no longer abstract in Java8 (default instead)
 		exceptionsTest(remove, UnresolvedType.NONE);
 
 		ResolvedMember clone = iter.lookupMethod(MemberImpl.method(UnresolvedType.OBJECT, 0, "clone", "()Ljava/lang/Object;"));

weaver5/java5-src/org/aspectj/weaver/reflect/Java15ReflectionBasedReferenceTypeDelegate.java

 		}
 		return annotations;
 	}
+	
+	@Override
+	public boolean hasAnnotations() {
+		if (annotations == null) {
+			annotations = annotationFinder.getAnnotations(getBaseClass(), getWorld());
+		}
+		return annotations.length != 0;
+	}
 
 	@Override
 	public boolean hasAnnotation(UnresolvedType ofType) {