diff options
18 files changed, 1349 insertions, 38 deletions
diff --git a/ajbrowser/src/org/aspectj/tools/ajbrowser/BrowserProperties.java b/ajbrowser/src/org/aspectj/tools/ajbrowser/BrowserProperties.java index 9c69722ce..86810b961 100644 --- a/ajbrowser/src/org/aspectj/tools/ajbrowser/BrowserProperties.java +++ b/ajbrowser/src/org/aspectj/tools/ajbrowser/BrowserProperties.java @@ -9,6 +9,7 @@ * * Contributors: * Xerox/PARC initial implementation + * AMC 01.20.2003 extended for new AspectJ 1.1 project options * ******************************************************************/ @@ -143,4 +144,21 @@ public class BrowserProperties implements ProjectPropertiesAdapter { public void setAjcWorkingDir(String path) { preferencesAdapter.setProjectPreference("build.workingdir", path); } + + // 1.1 options + public Set getInJars( ) { + return null; + } + + public String getOutJar( ) { + return null; + } + + public Set getSourceRoots( ) { + return null; + } + + public Set getAspectPath( ) { + return null; + } } diff --git a/ajde/src/org/aspectj/ajde/BuildOptionsAdapter.java b/ajde/src/org/aspectj/ajde/BuildOptionsAdapter.java index edf4c0972..7e89a55fa 100644 --- a/ajde/src/org/aspectj/ajde/BuildOptionsAdapter.java +++ b/ajde/src/org/aspectj/ajde/BuildOptionsAdapter.java @@ -8,61 +8,100 @@ * http://www.eclipse.org/legal/cpl-v10.html * * Contributors: - * Xerox/PARC initial implementation + * Xerox/PARC initial implementation + * AMC 01.20.2003 extended for AspectJ 1.1 compiler options * ******************************************************************/ package org.aspectj.ajde; +import java.util.Set; + /** * When a particular option is not set its documented default is used. */ public interface BuildOptionsAdapter { + // Version constants + public static final String VERSION_13 = "1.3"; + public static final String VERSION_14 = "1.4"; + + // Warning constants + public static final String WARN_CONSTRUCTOR_NAME = "constructorName"; + public static final String WARN_PACKAGE_DEFAULT_METHOD = "packageDefaultMethod"; + public static final String WARN_DEPRECATION = "deprecation"; + public static final String WARN_MASKED_CATCH_BLOCKS = "maskedCatchBlocks"; + public static final String WARN_UNUSED_LOCALS = "unusedLocals"; + public static final String WARN_UNUSED_ARGUMENTS = "unusedArguments"; + public static final String WARN_UNUSED_IMPORTS = "unusedImports"; + public static final String WARN_SYNTHETIC_ACCESS = "syntheticAccess"; + public static final String WARN_ASSERT_IDENITIFIER = "assertIdentifier"; + public static final String WARN_NLS = "nonExternalisedString"; + + // Debug constants + public static final String DEBUG_SOURCE = "source"; + public static final String DEBUG_LINES = "lines"; + public static final String DEBUG_VARS = "vars"; + public static final String DEBUG_ALL = "all"; + /** * Use javac to generate .class files. The default is "false". + * From -usejavac + * @deprecated Not supported from AspectJ 1.1 onwards */ public boolean getUseJavacMode(); /** * Only relevant with Use Javac or Preprocess modes. Specify where to place * intermediate .java files. The default is "workingdir". + * From -workingdir + * @deprecated Not supported from AspectJ 1.1 onwards */ public String getWorkingOutputPath(); /** * Generate regular Java code into the Working OutputPath. Don't try to generate * any .class files. The default is "false". + * From -source + * @deprecated Not supported from AspectJ 1.1 onwards */ public boolean getPreprocessMode(); /** * Specify character encoding used by source files. The default is the current * JVM's default. + * From -encoding */ public String getCharacterEncoding(); /** * Support assertions as defined in JLS-1.4. The default is "false". + * @deprecated Use getComplianceLevel instead */ public boolean getSourceOnePointFourMode(); /** * Be extra-lenient in interpreting the Java specification. The default is "false", * i.e. "regular" mode. + * From -lenient + * @deprecated Not supported from AspectJ 1.1 onwards */ public boolean getLenientSpecMode(); /** * Be extra-strict in interpreting the Java specification. The default is "false", * i.e. "regular" mode. + * From -strict + * @deprecated Not supported from AspectJ 1.1 onwards */ public boolean getStrictSpecMode(); /** * Make the use of some features from pre-1.0 versions of AspectJ be warnings to ease * porting of old code. The default is "false". + * From -porting + * @deprecated Not supported from AspectJ 1.1 onwards */ public boolean getPortingMode(); @@ -71,4 +110,48 @@ public interface BuildOptionsAdapter { * The default is no non-standard options. */ public String getNonStandardOptions(); + + // ---------------------------------- + // New options added for AspectJ 1.1 from this point onwards + + /** + * JDK Compliance level to be used by the compiler, either + * VERSION_13 or VERSION_14. + * From -1.3 / -1.4 + */ + public String getComplianceLevel(); + + /** + * Source compatibility level, either VERSION_13 or VERSION_14. + * From -source (eclipse option) + */ + public String getSourceCompatibilityLevel(); + + /** + * Optional warnings, empty List is equivalent to -warn:none, + * returning null uses eclipse compiler default settings + * From -warn:xxx,yyy + */ + public Set getWarnings(); + + /** + * Debug level. DEBUG_ALL == {SOURCE, LINES, VARS}. + * Empty list is equivalent to -g:none, returning + * non uses eclipse compiler default settings + * From -g:xxx + */ + public Set getDebugLevel(); + + /** + * No errors generated for unresolved imports + * From -noImportError + */ + public boolean getNoImportError(); + + /** + * Preserve all unused local variables (for debug) + * From -preserveAllLocals + */ + public boolean getPreserveAllLocals(); + } diff --git a/ajde/src/org/aspectj/ajde/ProjectPropertiesAdapter.java b/ajde/src/org/aspectj/ajde/ProjectPropertiesAdapter.java index e24307320..472a8425d 100644 --- a/ajde/src/org/aspectj/ajde/ProjectPropertiesAdapter.java +++ b/ajde/src/org/aspectj/ajde/ProjectPropertiesAdapter.java @@ -8,13 +8,15 @@ * http://www.eclipse.org/legal/cpl-v10.html * * Contributors: - * Xerox/PARC initial implementation + * Xerox/PARC initial implementation + * AMC 01.20.2003 extended for AspectJ 1.1 compiler options * ******************************************************************/ package org.aspectj.ajde; +import java.util.Set; import java.util.List; /** @@ -55,4 +57,38 @@ public interface ProjectPropertiesAdapter { public String getExecutionArgs(); public String getVmArgs(); + + // following methods added for AspectJ 1.1 + //----------------------------------------- + + /** + * Get the set of input jar files for this compilation. + * Set members should be of type java.io.File. + * An empty set or null is acceptable for this option. + * From -injars. + */ + public Set getInJars(); + + /** + * Get the output jar file for the compilation results. + * Return null to leave classfiles unjar'd in output directory + * From -outjar + */ + public String getOutJar(); + + /** + * Get a set of root source directories for the compilation. + * Set members should be of type java.io.File + * Returning null or an empty set disables the option. + * From -sourceroots + */ + public Set getSourceRoots(); + + /** + * Get the set of aspect jar files to be used for the compilation. + * Returning null or an empty set disables this option. Set members + * should be of type java.io.File. + * From -aspectpath + */ + public Set getAspectPath(); } diff --git a/ajde/src/org/aspectj/ajde/internal/AspectJBuildManager.java b/ajde/src/org/aspectj/ajde/internal/AspectJBuildManager.java index a52117e38..1c3e201d8 100644 --- a/ajde/src/org/aspectj/ajde/internal/AspectJBuildManager.java +++ b/ajde/src/org/aspectj/ajde/internal/AspectJBuildManager.java @@ -238,19 +238,49 @@ public class AspectJBuildManager implements BuildManager { notifyCompileFinished(configFile, lastCompileTime, succeeded, warnings); } + // AMC - updated for AspectJ 1.1 options private String getFormattedOptionsString(BuildOptionsAdapter buildOptions, ProjectPropertiesAdapter properties) { return "Building with settings: " + "\n-> output path: " + properties.getOutputPath() + "\n-> classpath: " + properties.getClasspath() + "\n-> bootclasspath: " + properties.getBootClasspath() + + "\n-> -injars " + formatSet(properties.getInJars()) + + "\n-> -outjar " + formatOptionalString(properties.getOutJar()) + + "\n-> -sourceroots " + formatSet(properties.getSourceRoots()) + + "\n-> -aspectpath " + formatSet(properties.getAspectPath()) + + "\n-> -" + buildOptions.getComplianceLevel() + + "\n-> -source " + buildOptions.getSourceCompatibilityLevel() + + "\n-> -g:" + formatSet(buildOptions.getDebugLevel()) + + "\n-> -warn:" + formatSet(buildOptions.getWarnings()) + + "\n-> noImportError: " + buildOptions.getNoImportError() + + "\n-> preserveAllLocals:" + buildOptions.getPreserveAllLocals() + "\n-> non-standard options: " + buildOptions.getNonStandardOptions() - + "\n-> porting mode: " + buildOptions.getPortingMode() - + "\n-> source 1.4 mode: " + buildOptions.getSourceOnePointFourMode() - + "\n-> strict spec mode: " + buildOptions.getStrictSpecMode() - + "\n-> lenient spec mode: " + buildOptions.getLenientSpecMode() - + "\n-> use javac mode: " + buildOptions.getUseJavacMode() - + "\n-> preprocess mode: " + buildOptions.getPreprocessMode() - + "\n-> working dir: " + buildOptions.getWorkingOutputPath(); + + "\n-> [ignored-deprecated in AspectJ1.1] porting mode: " + buildOptions.getPortingMode() + + "\n-> [ignored-deprecated in AspectJ1.1] source 1.4 mode: " + buildOptions.getSourceOnePointFourMode() + + "\n-> [ignored-deprecated in AspectJ1.1] strict spec mode: " + buildOptions.getStrictSpecMode() + + "\n-> [ignored-deprecated in AspectJ1.1] lenient spec mode: " + buildOptions.getLenientSpecMode() + + "\n-> [ignored-deprecated in AspectJ1.1] use javac mode: " + buildOptions.getUseJavacMode() + + "\n-> [ignored-deprecated in AspectJ1.1] preprocess mode: " + buildOptions.getPreprocessMode() + + "\n-> [ignored-deprecated in AspectJ1.1] working dir: " + buildOptions.getWorkingOutputPath(); + } + + private String formatSet( Set options ) { + if ( options == null ) return "<default>"; + if ( options.isEmpty() ) return "none"; + + StringBuffer formattedOptions = new StringBuffer(); + Iterator it = options.iterator(); + while (it.hasNext()) { + String o = it.next().toString(); + if (formattedOptions.length() > 0) formattedOptions.append(", "); + formattedOptions.append( o ); + } + return formattedOptions.toString(); + } + + private String formatOptionalString( String s ) { + if ( s == null ) { return "" ; } + else { return s; } } } diff --git a/ajde/src/org/aspectj/ajde/internal/CompilerAdapter.java b/ajde/src/org/aspectj/ajde/internal/CompilerAdapter.java index 19ede47fd..9279456a7 100644 --- a/ajde/src/org/aspectj/ajde/internal/CompilerAdapter.java +++ b/ajde/src/org/aspectj/ajde/internal/CompilerAdapter.java @@ -7,7 +7,9 @@ * http://www.eclipse.org/legal/cpl-v10.html * * Contributors: - * Xerox/PARC initial implementation + * Xerox/PARC initial implementation + * AMC 01.20.2003 extended to support new AspectJ 1.1 options, + * bugzilla #29769 * ******************************************************************/ @@ -17,10 +19,12 @@ import java.io.File; import java.util.*; import org.aspectj.ajde.*; +import org.aspectj.ajdt.ajc.BuildArgParser; import org.aspectj.ajdt.internal.core.builder.AjBuildConfig; import org.aspectj.ajdt.internal.core.builder.AjBuildManager; import org.aspectj.bridge.*; import org.aspectj.util.ConfigParser; +import org.aspectj.util.LangUtil; import org.eclipse.core.runtime.OperationCanceledException; import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; @@ -99,36 +103,263 @@ public class CompilerAdapter { buildConfig.setConfigFile(config); } + // AMC refactored into two methods to populate buildConfig from buildOptions and + // project properties - bugzilla 29769. + configureBuildOptions(buildConfig, Ajde.getDefault().getBuildManager().getBuildOptions()); + configureProjectOptions(buildConfig, Ajde.getDefault().getProjectProperties()); + + buildConfig.setGenerateModelMode(true); + return buildConfig; + } + + /** + * Populate options in a build configuration, using the Ajde BuildOptionsAdapter. + * Added by AMC 01.20.2003, bugzilla #29769 + */ + private void configureBuildOptions( AjBuildConfig config, BuildOptionsAdapter options ) { + + Map javaOptions = config.getJavaOptions(); + + if (options.getSourceOnePointFourMode()) { + javaOptions.put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_1_4); + javaOptions.put(CompilerOptions.OPTION_Source, CompilerOptions.VERSION_1_4); + } + + String enc = options.getCharacterEncoding(); + if ( enc != null & (enc.length() > 0)) { + javaOptions.put(CompilerOptions.OPTION_Encoding, enc ); + } + + String compliance = options.getComplianceLevel(); + if ( compliance != null && (compliance.length() > 0) ) { + String version = CompilerOptions.VERSION_1_4; + if ( compliance.equals( BuildOptionsAdapter.VERSION_13 ) ) { + version = CompilerOptions.VERSION_1_3; + } + javaOptions.put(CompilerOptions.OPTION_Compliance, version ); + javaOptions.put(CompilerOptions.OPTION_Source, version ); + } + + String sourceLevel = options.getSourceCompatibilityLevel(); + if ( null != sourceLevel && ( sourceLevel.length() > 0 )) { + String slVersion = CompilerOptions.VERSION_1_4; + if ( sourceLevel.equals( BuildOptionsAdapter.VERSION_13 ) ) { + slVersion = CompilerOptions.VERSION_1_3; + } + // never set a lower source level than compliance level + String setCompliance = (String) javaOptions.get( CompilerOptions.OPTION_Compliance); + if ( ! (setCompliance.equals( CompilerOptions.VERSION_1_4 ) + && slVersion.equals(CompilerOptions.VERSION_1_3)) ) { + javaOptions.put(CompilerOptions.OPTION_Source, slVersion); + } + } + + Set warnings = options.getWarnings(); + if ( warnings != null ) { + // turn off all warnings + disableWarnings( javaOptions ); + // then selectively enable those in the set + enableWarnings( javaOptions, warnings ); + } + + Set debugOptions = options.getDebugLevel(); + if ( debugOptions != null ) { + // default is all options off, so just need to selectively + // enable + Iterator it = debugOptions.iterator(); + while (it.hasNext()){ + String debug = (String) it.next(); + if ( debug.equals( BuildOptionsAdapter.DEBUG_ALL )) { + javaOptions.put( CompilerOptions.OPTION_LineNumberAttribute, + CompilerOptions.GENERATE); + javaOptions.put( CompilerOptions.OPTION_SourceFileAttribute, + CompilerOptions.GENERATE); + javaOptions.put( CompilerOptions.OPTION_LocalVariableAttribute, + CompilerOptions.GENERATE); + } else if ( debug.equals( BuildOptionsAdapter.DEBUG_LINES )) { + javaOptions.put( CompilerOptions.OPTION_LineNumberAttribute, + CompilerOptions.GENERATE); + } else if ( debug.equals( BuildOptionsAdapter.DEBUG_SOURCE )) { + javaOptions.put( CompilerOptions.OPTION_SourceFileAttribute, + CompilerOptions.GENERATE); + } else if ( debug.equals( BuildOptionsAdapter.DEBUG_VARS)) { + javaOptions.put( CompilerOptions.OPTION_LocalVariableAttribute, + CompilerOptions.GENERATE); + } + } + } + + if ( options.getNoImportError() ) { + javaOptions.put( CompilerOptions.OPTION_ReportInvalidImport, + CompilerOptions.WARNING); + } + + if ( options.getPreserveAllLocals() ) { + javaOptions.put( CompilerOptions.OPTION_PreserveUnusedLocal, + CompilerOptions.PRESERVE); + } + + config.setJavaOptions( javaOptions ); + + configureNonStandardOptions( config, options ); + } + + /** + * Helper method for configureBuildOptions + */ + private void disableWarnings( Map options ) { + options.put( + CompilerOptions.OPTION_ReportOverridingPackageDefaultMethod, + CompilerOptions.IGNORE); + options.put( + CompilerOptions.OPTION_ReportMethodWithConstructorName, + CompilerOptions.IGNORE); + options.put( + CompilerOptions.OPTION_ReportDeprecation, + CompilerOptions.IGNORE); + options.put( + CompilerOptions.OPTION_ReportHiddenCatchBlock, + CompilerOptions.IGNORE); + options.put( + CompilerOptions.OPTION_ReportUnusedLocal, + CompilerOptions.IGNORE); + options.put( + CompilerOptions.OPTION_ReportUnusedParameter, + CompilerOptions.IGNORE); + options.put( + CompilerOptions.OPTION_ReportSyntheticAccessEmulation, + CompilerOptions.IGNORE); + options.put( + CompilerOptions.OPTION_ReportNonExternalizedStringLiteral, + CompilerOptions.IGNORE); + options.put( + CompilerOptions.OPTION_ReportAssertIdentifier, + CompilerOptions.IGNORE); + options.put( + CompilerOptions.OPTION_ReportUnusedImport, + CompilerOptions.IGNORE); + } + + /** + * Helper method for configureBuildOptions + */ + private void enableWarnings( Map options, Set warnings ) { + Iterator it = warnings.iterator(); + while (it.hasNext() ) { + String thisWarning = (String) it.next(); + if ( thisWarning.equals( BuildOptionsAdapter.WARN_ASSERT_IDENITIFIER )) { + options.put( CompilerOptions.OPTION_ReportAssertIdentifier, + CompilerOptions.WARNING ); + } else if ( thisWarning.equals( BuildOptionsAdapter.WARN_CONSTRUCTOR_NAME )) { + options.put( CompilerOptions.OPTION_ReportMethodWithConstructorName, + CompilerOptions.WARNING ); + } else if ( thisWarning.equals( BuildOptionsAdapter.WARN_DEPRECATION )) { + options.put( CompilerOptions.OPTION_ReportDeprecation, + CompilerOptions.WARNING ); + } else if ( thisWarning.equals( BuildOptionsAdapter.WARN_MASKED_CATCH_BLOCKS )) { + options.put( CompilerOptions.OPTION_ReportHiddenCatchBlock, + CompilerOptions.WARNING ); + } else if ( thisWarning.equals( BuildOptionsAdapter.WARN_PACKAGE_DEFAULT_METHOD )) { + options.put( CompilerOptions.OPTION_ReportOverridingPackageDefaultMethod, + CompilerOptions.WARNING ); + } else if ( thisWarning.equals( BuildOptionsAdapter.WARN_SYNTHETIC_ACCESS )) { + options.put( CompilerOptions.OPTION_ReportSyntheticAccessEmulation, + CompilerOptions.WARNING ); + } else if ( thisWarning.equals( BuildOptionsAdapter.WARN_UNUSED_ARGUMENTS )) { + options.put( CompilerOptions.OPTION_ReportUnusedParameter, + CompilerOptions.WARNING ); + } else if ( thisWarning.equals( BuildOptionsAdapter.WARN_UNUSED_IMPORTS )) { + options.put( CompilerOptions.OPTION_ReportUnusedImport, + CompilerOptions.WARNING ); + } else if ( thisWarning.equals( BuildOptionsAdapter.WARN_UNUSED_LOCALS )) { + options.put( CompilerOptions.OPTION_ReportUnusedLocal, + CompilerOptions.WARNING ); + } else if ( thisWarning.equals( BuildOptionsAdapter.WARN_NLS )) { + options.put( CompilerOptions.OPTION_ReportNonExternalizedStringLiteral, + CompilerOptions.WARNING ); + } + } + } + + + /** + * Helper method for configure build options + */ + private void configureNonStandardOptions( AjBuildConfig config, BuildOptionsAdapter options ) { + String nonStdOptions = options.getNonStandardOptions(); + if ( null == nonStdOptions || (nonStdOptions.length() == 0)) return; + + StringTokenizer tok = new StringTokenizer( nonStdOptions ); + String[] args = new String[ tok.countTokens() ]; + int argCount = 0; + while ( tok.hasMoreTokens() ) { + args[argCount++] = tok.nextToken(); + } + + // set the non-standard options in an alternate build config + // (we don't want to lose the settings we already have) + BuildArgParser argParser = new BuildArgParser(); + AjBuildConfig altConfig = argParser.genBuildConfig( args, messageHandler ); + + // copy the answers across + config.setNoWeave( altConfig.isNoWeave() ); + config.setXnoInline( altConfig.isXnoInline() ); + config.setXserializableAspects( altConfig.isXserializableAspects()); + config.setLintMode( altConfig.getLintMode() ); + config.setLintSpecFile( altConfig.getLintSpecFile() ); + } + /** + * Populate options in a build configuration, using the ProjectPropertiesAdapter. + * Added by AMC 01.20.2003, bugzilla #29769 + */ + private void configureProjectOptions( AjBuildConfig config, ProjectPropertiesAdapter properties ) { + + // set the classpath String classpathString = - Ajde.getDefault().getProjectProperties().getBootClasspath() + properties.getBootClasspath() + File.pathSeparator - + Ajde.getDefault().getProjectProperties().getClasspath(); + + properties.getClasspath(); StringTokenizer st = new StringTokenizer( classpathString, File.pathSeparator ); + List classpath = new ArrayList(); while (st.hasMoreTokens()) classpath.add(st.nextToken()); - buildConfig.setClasspath(classpath); + config.setClasspath(classpath); Ajde.getDefault().logEvent("building with classpath: " + classpath); - if (Ajde.getDefault().getBuildManager().getBuildOptions().getSourceOnePointFourMode()) { - buildConfig.getJavaOptions().put(CompilerOptions.OPTION_Compliance, CompilerOptions.VERSION_1_4); - } + config.setOutputDir( + new File(properties.getOutputPath()) + ); - // XXX problematic restriction, support multiple source roots - List sourceRoots = new ArrayList(); - sourceRoots.add(new File(configFile).getParentFile()); - buildConfig.setSourceRoots(sourceRoots); + // new 1.1 options added by AMC - buildConfig.setOutputDir( - new File(Ajde.getDefault().getProjectProperties().getOutputPath()) - ); + Set roots = properties.getSourceRoots(); + if ( null != roots && !roots.isEmpty() ) { + List sourceRoots = new ArrayList( roots ); + config.setSourceRoots(sourceRoots); + } - buildConfig.setGenerateModelMode(true); + Set jars = properties.getInJars(); + if ( null != jars && !jars.isEmpty() ) { + List inJars = new ArrayList( jars ); + config.setInJars(inJars); + } - return buildConfig; + String outJar = properties.getOutJar(); + if ( null != outJar && (outJar.length() > 0) ) { + config.setOutputJar( new File( outJar ) ); + } + + Set aspects = properties.getAspectPath(); + if ( null != aspects && !aspects.isEmpty() ) { + List aPath = new ArrayList( aspects ); + config.setAspectpath( aPath); + } + + } private void init() { diff --git a/ajde/src/org/aspectj/ajde/ui/internal/AjcBuildOptions.java b/ajde/src/org/aspectj/ajde/ui/internal/AjcBuildOptions.java index 3093d09a0..da53c5c09 100644 --- a/ajde/src/org/aspectj/ajde/ui/internal/AjcBuildOptions.java +++ b/ajde/src/org/aspectj/ajde/ui/internal/AjcBuildOptions.java @@ -9,12 +9,19 @@ * * Contributors: * Xerox/PARC initial implementation + * AMC 01.20.2003 extended to support AspectJ 1.1 options, + * bugzilla #29769 * ******************************************************************/ package org.aspectj.ajde.ui.internal; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; +import java.util.StringTokenizer; + import org.aspectj.ajde.*; import org.aspectj.ajde.ui.*; @@ -33,31 +40,46 @@ public class AjcBuildOptions implements BuildOptionsAdapter { private static final String PORTING_MODE = AJC + ".portingMode"; private static final String VERBOSE_MODE = AJC + ".verboseMode"; private static final String NONSTANDARD_OPTIONS = AJC + ".nonStandardOptions"; + // 1.1 constants added by AMC + private static final String COMPLIANCE_LEVEL = AJC + ".complianceLevel"; + private static final String SOURCE_LEVEL = AJC + ".sourceLevel"; + private static final String WARNINGS = AJC + ".warnings"; + private static final String DEBUG_OPTIONS = AJC + ".debugOptions"; + private static final String NO_IMPORT_ERROR = AJC + ".noImportError"; + private static final String PRESERVE_LOCALS = AJC + ".preserveLocals"; + private static final String DEFAULT = "default"; + public AjcBuildOptions(UserPreferencesAdapter userPreferencesAdapter) { this.preferencesAdapter = userPreferencesAdapter; } - + + /** @deprecated */ public boolean getUseJavacMode() { return getBooleanOptionVal(USE_JAVAC_MODE); } + /** @deprecated */ public void setUseJavacMode(boolean value) { setBooleanOptionVal(USE_JAVAC_MODE, value); } + /** @deprecated */ public String getWorkingOutputPath() { return preferencesAdapter.getProjectPreference(WORKING_DIR); } + /** @deprecated */ public void setWorkingDir(String path) { preferencesAdapter.setProjectPreference(WORKING_DIR, path); } + /** @deprecated */ public boolean getPreprocessMode() { return getBooleanOptionVal(PREPROCESS_MODE); } + /** @deprecated */ public void setPreprocessMode(boolean value) { setBooleanOptionVal(PREPROCESS_MODE, value); } @@ -70,34 +92,42 @@ public class AjcBuildOptions implements BuildOptionsAdapter { preferencesAdapter.setProjectPreference(CHARACTER_ENCODING, value); } + /** @deprecated */ public boolean getSourceOnePointFourMode() { return getBooleanOptionVal(SOURCE_ONE_POINT_FOUR_MODE); } + /** @deprecated */ public void setSourceOnePointFourMode(boolean value) { setBooleanOptionVal(SOURCE_ONE_POINT_FOUR_MODE, value); } + /** @deprecated */ public boolean getLenientSpecMode() { return getBooleanOptionVal(LENIENT_MODE); } + /** @deprecated */ public void setLenientSpecMode(boolean value) { setBooleanOptionVal(LENIENT_MODE, value); } + /** @deprecated */ public boolean getStrictSpecMode() { return getBooleanOptionVal(STRICT_MODE); } + /** @deprecated */ public void setStrictSpecMode(boolean value) { setBooleanOptionVal(STRICT_MODE, value); } + /** @deprecated */ public boolean getPortingMode() { return getBooleanOptionVal(PORTING_MODE); } + /** @deprecated */ public void setPortingMode(boolean value) { setBooleanOptionVal(PORTING_MODE, value); } @@ -117,6 +147,89 @@ public class AjcBuildOptions implements BuildOptionsAdapter { public void setNonStandardOptions(String value) { preferencesAdapter.setProjectPreference(NONSTANDARD_OPTIONS, value); } + + // ------------- + // new 1.1 compiler options start here... + + /** + * JDK Compliance level to be used by the compiler, either + * VERSION_13 or VERSION_14. + * From -1.3 / -1.4 + */ + public String getComplianceLevel() { + return preferencesAdapter.getProjectPreference(COMPLIANCE_LEVEL); + } + + public void setComplianceLevel( String value ) { + preferencesAdapter.setProjectPreference(COMPLIANCE_LEVEL,value); + } + + /** + * Source compatibility level, either VERSION_13 or VERSION_14. + * From -source (eclipse option) + */ + public String getSourceCompatibilityLevel() { + return preferencesAdapter.getProjectPreference(SOURCE_LEVEL); + } + + public void setSourceCompatibilityLevel(String value) { + preferencesAdapter.setProjectPreference(SOURCE_LEVEL, value); + } + + /** + * Optional warnings, empty List is equivalent to -warn:none, + * returning null uses eclipse compiler default settings + * From -warn:xxx,yyy + */ + public Set getWarnings() { + String warnings = preferencesAdapter.getProjectPreference(WARNINGS); + return toWarningSet( warnings ); + } + + public void setWarnings( Set warningSet ) { + String warnings = fromWarningSet( warningSet ); + preferencesAdapter.setProjectPreference(WARNINGS, warnings); + } + + /** + * Debug level. DEBUG_ALL == {SOURCE, LINES, VARS}. + * Empty list is equivalent to -g:none, returning + * non uses eclipse compiler default settings + * From -g:xxx + */ + public Set getDebugLevel() { + String debug = preferencesAdapter.getProjectPreference(DEBUG_OPTIONS); + return toDebugSet( debug ); + } + + public void setDebugLevel( Set debugSet ) { + String debug = fromDebugSet( debugSet ); + preferencesAdapter.setProjectPreference(DEBUG_OPTIONS, debug); + } + + /** + * No errors generated for unresolved imports + * From -noImportError + */ + public boolean getNoImportError() { + return getBooleanOptionVal(NO_IMPORT_ERROR); + } + + public void setNoImportError(boolean value) { + setBooleanOptionVal(NO_IMPORT_ERROR, value); + } + + /** + * Preserve all unused local variables (for debug) + * From -preserveAllLocals + */ + public boolean getPreserveAllLocals() { + return getBooleanOptionVal(PRESERVE_LOCALS); + } + + public void setPreserveAllLocals(boolean value) { + setBooleanOptionVal(PRESERVE_LOCALS, value); + } private boolean getBooleanOptionVal(String name) { if (preferencesAdapter.getProjectPreference(name) != null) { @@ -133,4 +246,56 @@ public class AjcBuildOptions implements BuildOptionsAdapter { preferencesAdapter.setProjectPreference(name, "false"); } } + + private Set toWarningSet( String warnings ) { + if ( null == warnings ) return null; + if ( warnings.equals(DEFAULT) ) return null; + + Set warningSet = new HashSet(); + StringTokenizer tok = new StringTokenizer( warnings, "," ); + while ( tok.hasMoreTokens() ) { + String warning = tok.nextToken(); + warningSet.add( warning ); + } + return warningSet; + } + + private String fromWarningSet( Set warningSet ) { + if ( warningSet == null ) return DEFAULT; + + StringBuffer warnings = new StringBuffer(); + Iterator it = warningSet.iterator(); + while ( it.hasNext() ) { + String w = (String) it.next(); + if (warnings.length() > 0 ) warnings.append(','); + warnings.append( w ); + } + return warnings.toString(); + } + + private Set toDebugSet( String debugOptions ) { + if ( null == debugOptions ) return null; + if ( debugOptions.equals(DEFAULT) ) return null; + + Set debugSet = new HashSet(); + StringTokenizer tok = new StringTokenizer( debugOptions, "," ); + while ( tok.hasMoreTokens() ) { + String debug = tok.nextToken(); + debugSet.add( debug ); + } + return debugSet; } + + private String fromDebugSet( Set debugSet ) { + if ( debugSet == null ) return DEFAULT; + + StringBuffer debugOptions = new StringBuffer(); + Iterator it = debugSet.iterator(); + while ( it.hasNext() ) { + String d = (String) it.next(); + if (debugOptions.length() > 0 ) debugOptions.append(','); + debugOptions.append( d ); + } + return debugOptions.toString(); + } + } diff --git a/ajde/testdata/examples/figures-coverage/figures/Figure.java b/ajde/testdata/examples/figures-coverage/figures/Figure.java index 9bf5e0f8b..e7f5da0c8 100644 --- a/ajde/testdata/examples/figures-coverage/figures/Figure.java +++ b/ajde/testdata/examples/figures-coverage/figures/Figure.java @@ -1,7 +1,7 @@ package figures; -//import figures.primitives.planar.Point; +import figures.primitives.planar.Point; import java.awt.Canvas; @@ -73,7 +73,9 @@ aspect Figure { declare parents: Point implements java.util.Observable; - declare soft: Point: call(* *(..)); + // AMC - this next line doesn't make sense!! Can these tests ever + // have been run??? + //declare soft: Point: call(* *(..)); } aspect Checks { diff --git a/ajde/testsrc/org/aspectj/ajde/AjdeTests.java b/ajde/testsrc/org/aspectj/ajde/AjdeTests.java index d2cd8fe9f..4a0140e90 100644 --- a/ajde/testsrc/org/aspectj/ajde/AjdeTests.java +++ b/ajde/testsrc/org/aspectj/ajde/AjdeTests.java @@ -22,6 +22,7 @@ public class AjdeTests extends TestCase { TestSuite suite = new TestSuite(AjdeTests.class.getName()); //$JUnit-BEGIN$ suite.addTestSuite(BuildOptionsTest.class); + suite.addTestSuite(BuildConfigurationTests.class); suite.addTestSuite(StructureModelRegressionTest.class); suite.addTestSuite(StructureModelTest.class); suite.addTestSuite(VersionTest.class); diff --git a/ajde/testsrc/org/aspectj/ajde/BuildConfigurationTests.java b/ajde/testsrc/org/aspectj/ajde/BuildConfigurationTests.java new file mode 100644 index 000000000..a59320966 --- /dev/null +++ b/ajde/testsrc/org/aspectj/ajde/BuildConfigurationTests.java @@ -0,0 +1,506 @@ +/********************************************************************** +Copyright (c) 2003 IBM Corporation and others. +All rights reserved. This program and the accompanying materials +are made available under the terms of the Common Public License v1.0 +which accompanies this distribution, and is available at +http://www.eclipse.org/legal/cpl-v10.html +Contributors: +Adrian Colyer - initial version +... +**********************************************************************/ +package org.aspectj.ajde; + +import java.io.File; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import javax.swing.JFrame; + +import junit.framework.TestSuite; + +import org.aspectj.ajde.internal.CompilerAdapter; +import org.aspectj.ajde.ui.IdeUIAdapter; +import org.aspectj.ajde.ui.UserPreferencesAdapter; +import org.aspectj.ajde.ui.internal.AjcBuildOptions; +import org.aspectj.ajde.ui.internal.UserPreferencesStore; +import org.aspectj.ajde.ui.swing.AjdeUIManager; +import org.aspectj.ajde.ui.swing.BasicEditor; +import org.aspectj.ajde.ui.swing.IconRegistry; +import org.aspectj.ajdt.internal.core.builder.AjBuildConfig; +import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; + +/** + * Tests that a correctly populated AjBuildConfig object is created + * in reponse to the setting in BuildOptionsAdapter and + * ProjectPropretiesAdapter + */ +public class BuildConfigurationTests extends AjdeTestCase { + + private CompilerAdapter compilerAdapter; + private AjBuildConfig buildConfig = null; + private AjcBuildOptions buildOptions = null; + private UserPreferencesAdapter preferencesAdapter = null; + private NullIdeProperties projectProperties = null; + private static final String configFile = + "testdata/examples/figures-coverage/all.lst"; + + + public BuildConfigurationTests( String name ) { + super( name ); + } + + public static void main(String[] args) { + junit.swingui.TestRunner.run(BuildConfigurationTests.class); + } + + public static TestSuite suite() { + TestSuite result = new TestSuite(); + result.addTestSuite(BuildConfigurationTests.class); + return result; + } + + + // The tests... + public void testCharacterEncoding() { + buildOptions.setCharacterEncoding( "12345" ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + String encoding = (String) options.get( CompilerOptions.OPTION_Encoding ); + assertEquals( "character encoding", "12345", encoding ); + } + + public void testComplianceLevel() { + buildOptions.setComplianceLevel( BuildOptionsAdapter.VERSION_14 ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + String compliance = (String) options.get(CompilerOptions.OPTION_Compliance); + String sourceLevel = (String) options.get(CompilerOptions.OPTION_Source); + assertEquals( "compliance level", CompilerOptions.VERSION_1_4, compliance); + assertEquals( "source level", CompilerOptions.VERSION_1_4, sourceLevel ); + } + + public void testSourceCompatibilityLevel() { + buildOptions.setComplianceLevel( BuildOptionsAdapter.VERSION_13); + buildOptions.setSourceCompatibilityLevel( BuildOptionsAdapter.VERSION_14); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + String compliance = (String) options.get(CompilerOptions.OPTION_Compliance); + String sourceLevel = (String) options.get(CompilerOptions.OPTION_Source); + assertEquals( "compliance level", CompilerOptions.VERSION_1_3, compliance); + assertEquals( "source level", CompilerOptions.VERSION_1_4, sourceLevel ); + } + + public void testSourceIncompatibilityLevel() { + // this config should "fail" and leave source level at 1.4 + buildOptions.setComplianceLevel( BuildOptionsAdapter.VERSION_14); + buildOptions.setSourceCompatibilityLevel( BuildOptionsAdapter.VERSION_13); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + String compliance = (String) options.get(CompilerOptions.OPTION_Compliance); + String sourceLevel = (String) options.get(CompilerOptions.OPTION_Source); + assertEquals( "compliance level", CompilerOptions.VERSION_1_4, compliance); + assertEquals( "source level", CompilerOptions.VERSION_1_4, sourceLevel ); + } + + + public void testNullWarnings() { + buildOptions.setWarnings( null ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + + // this should leave us with the default warnings + assertOptionEquals( "report overriding package default", + options, + CompilerOptions.OPTION_ReportOverridingPackageDefaultMethod, + CompilerOptions.WARNING); + assertOptionEquals( "report method with cons name", + options, + CompilerOptions.OPTION_ReportMethodWithConstructorName, + CompilerOptions.WARNING); + assertOptionEquals( "report deprecation", + options, + CompilerOptions.OPTION_ReportDeprecation, + CompilerOptions.WARNING); + assertOptionEquals( "report hidden catch block", + options, + CompilerOptions.OPTION_ReportHiddenCatchBlock, + CompilerOptions.WARNING); + assertOptionEquals( "report unused local", + options, + CompilerOptions.OPTION_ReportUnusedLocal, + CompilerOptions.IGNORE); + assertOptionEquals( "report unused param", + options, + CompilerOptions.OPTION_ReportUnusedParameter, + CompilerOptions.IGNORE); + assertOptionEquals( "report synthectic access", + options, + CompilerOptions.OPTION_ReportSyntheticAccessEmulation, + CompilerOptions.IGNORE); + assertOptionEquals( "report non-externalized string literal", + options, + CompilerOptions.OPTION_ReportNonExternalizedStringLiteral, + CompilerOptions.IGNORE); + assertOptionEquals( "report assert identifer", + options, + CompilerOptions.OPTION_ReportAssertIdentifier, + CompilerOptions.IGNORE); + } + + public void testEmptyWarnings() { + buildOptions.setWarnings( new HashSet() ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + + // this should leave us with the user specifiable warnings + // turned off + assertOptionEquals( "report overriding package default", + options, + CompilerOptions.OPTION_ReportOverridingPackageDefaultMethod, + CompilerOptions.IGNORE); + assertOptionEquals( "report method with cons name", + options, + CompilerOptions.OPTION_ReportMethodWithConstructorName, + CompilerOptions.IGNORE); + assertOptionEquals( "report deprecation", + options, + CompilerOptions.OPTION_ReportDeprecation, + CompilerOptions.IGNORE); + assertOptionEquals( "report hidden catch block", + options, + CompilerOptions.OPTION_ReportHiddenCatchBlock, + CompilerOptions.IGNORE); + assertOptionEquals( "report unused local", + options, + CompilerOptions.OPTION_ReportUnusedLocal, + CompilerOptions.IGNORE); + assertOptionEquals( "report unused param", + options, + CompilerOptions.OPTION_ReportUnusedParameter, + CompilerOptions.IGNORE); + assertOptionEquals( "report synthectic access", + options, + CompilerOptions.OPTION_ReportSyntheticAccessEmulation, + CompilerOptions.IGNORE); + assertOptionEquals( "report non-externalized string literal", + options, + CompilerOptions.OPTION_ReportNonExternalizedStringLiteral, + CompilerOptions.IGNORE); + assertOptionEquals( "report assert identifer", + options, + CompilerOptions.OPTION_ReportAssertIdentifier, + CompilerOptions.IGNORE); + } + + public void testSetOfWarnings() { + HashSet warnings = new HashSet(); + warnings.add( BuildOptionsAdapter.WARN_ASSERT_IDENITIFIER ); + warnings.add( BuildOptionsAdapter.WARN_CONSTRUCTOR_NAME ); + warnings.add( BuildOptionsAdapter.WARN_DEPRECATION ); + warnings.add( BuildOptionsAdapter.WARN_MASKED_CATCH_BLOCKS ); + warnings.add( BuildOptionsAdapter.WARN_PACKAGE_DEFAULT_METHOD ); + warnings.add( BuildOptionsAdapter.WARN_SYNTHETIC_ACCESS ); + warnings.add( BuildOptionsAdapter.WARN_UNUSED_ARGUMENTS ); + warnings.add( BuildOptionsAdapter.WARN_UNUSED_IMPORTS ); + warnings.add( BuildOptionsAdapter.WARN_UNUSED_LOCALS ); + warnings.add( BuildOptionsAdapter.WARN_NLS ); + + buildOptions.setWarnings( warnings ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + + // this should leave us with all the user specifiable warnings + // turned on + assertOptionEquals( "report overriding package default", + options, + CompilerOptions.OPTION_ReportOverridingPackageDefaultMethod, + CompilerOptions.WARNING); + assertOptionEquals( "report method with cons name", + options, + CompilerOptions.OPTION_ReportMethodWithConstructorName, + CompilerOptions.WARNING); + assertOptionEquals( "report deprecation", + options, + CompilerOptions.OPTION_ReportDeprecation, + CompilerOptions.WARNING); + assertOptionEquals( "report hidden catch block", + options, + CompilerOptions.OPTION_ReportHiddenCatchBlock, + CompilerOptions.WARNING); + assertOptionEquals( "report unused local", + options, + CompilerOptions.OPTION_ReportUnusedLocal, + CompilerOptions.WARNING); + assertOptionEquals( "report unused param", + options, + CompilerOptions.OPTION_ReportUnusedParameter, + CompilerOptions.WARNING); + assertOptionEquals( "report synthectic access", + options, + CompilerOptions.OPTION_ReportSyntheticAccessEmulation, + CompilerOptions.WARNING); + assertOptionEquals( "report non-externalized string literal", + options, + CompilerOptions.OPTION_ReportNonExternalizedStringLiteral, + CompilerOptions.WARNING); + assertOptionEquals( "report assert identifer", + options, + CompilerOptions.OPTION_ReportAssertIdentifier, + CompilerOptions.WARNING); + } + + public void testNoDebugOptions() { + buildOptions.setDebugLevel( null ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + + // this should leave us with the default debug settings + assertOptionEquals( "debug source", + options, + CompilerOptions.OPTION_SourceFileAttribute, + CompilerOptions.DO_NOT_GENERATE); + assertOptionEquals( "debug lines", + options, + CompilerOptions.OPTION_LineNumberAttribute, + CompilerOptions.DO_NOT_GENERATE); + assertOptionEquals( "debug vars", + options, + CompilerOptions.OPTION_LocalVariableAttribute, + CompilerOptions.DO_NOT_GENERATE); + } + + public void testEmptyDebugOptions() { + buildOptions.setDebugLevel( new HashSet() ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + + // this should leave us with the debug off + assertOptionEquals( "debug source", + options, + CompilerOptions.OPTION_SourceFileAttribute, + CompilerOptions.DO_NOT_GENERATE); + assertOptionEquals( "debug lines", + options, + CompilerOptions.OPTION_LineNumberAttribute, + CompilerOptions.DO_NOT_GENERATE); + assertOptionEquals( "debug vars", + options, + CompilerOptions.OPTION_LocalVariableAttribute, + CompilerOptions.DO_NOT_GENERATE); + } + + public void testDebugAll() { + HashSet debugOpts = new HashSet(); + debugOpts.add( BuildOptionsAdapter.DEBUG_ALL ); + buildOptions.setDebugLevel( debugOpts ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + + // this should leave us with all debug on + assertOptionEquals( "debug source", + options, + CompilerOptions.OPTION_SourceFileAttribute, + CompilerOptions.GENERATE); + assertOptionEquals( "debug lines", + options, + CompilerOptions.OPTION_LineNumberAttribute, + CompilerOptions.GENERATE); + assertOptionEquals( "debug vars", + options, + CompilerOptions.OPTION_LocalVariableAttribute, + CompilerOptions.GENERATE); + + } + + public void testDebugSet() { + HashSet debugOpts = new HashSet(); + debugOpts.add( BuildOptionsAdapter.DEBUG_SOURCE ); + debugOpts.add( BuildOptionsAdapter.DEBUG_VARS ); + buildOptions.setDebugLevel( debugOpts ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + + // this should leave us with all debug on + assertOptionEquals( "debug source", + options, + CompilerOptions.OPTION_SourceFileAttribute, + CompilerOptions.GENERATE); + assertOptionEquals( "debug lines", + options, + CompilerOptions.OPTION_LineNumberAttribute, + CompilerOptions.DO_NOT_GENERATE); + assertOptionEquals( "debug vars", + options, + CompilerOptions.OPTION_LocalVariableAttribute, + CompilerOptions.GENERATE); + } + + public void testNoImport() { + buildOptions.setNoImportError( true ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + String noImport = (String) options.get( CompilerOptions.OPTION_ReportInvalidImport ); + assertEquals( "no import", CompilerOptions.WARNING, noImport ); + buildOptions.setNoImportError( false ); + } + + public void testPreserveAllLocals() { + buildOptions.setPreserveAllLocals( true ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + Map options = buildConfig.getJavaOptions(); + String preserve = (String) options.get( CompilerOptions.OPTION_PreserveUnusedLocal ); + assertEquals( "preserve unused", CompilerOptions.PRESERVE, preserve ); + } + + public void testNonStandardOptions() { + buildOptions.setNonStandardOptions( "-XnoWeave" ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + assertTrue( "XnoWeave", buildConfig.isNoWeave() ); + buildOptions.setNonStandardOptions( "-XserializableAspects" ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + assertTrue( "XserializableAspects", buildConfig.isXserializableAspects() ); + buildOptions.setNonStandardOptions( "-XnoInline" ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + assertTrue( "XnoInline", buildConfig.isXnoInline()); + buildOptions.setNonStandardOptions( "-Xlint" ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + assertEquals( "Xlint", AjBuildConfig.AJLINT_DEFAULT, + buildConfig.getLintMode()); + buildOptions.setNonStandardOptions( "-Xlint:error" ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + assertEquals( "Xlint", AjBuildConfig.AJLINT_ERROR, + buildConfig.getLintMode()); + buildOptions.setNonStandardOptions( "-Xlintfile testdata/AspectJBuildManagerTest/lint.properties" ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + assertEquals( "Xlintfile", new File( "testdata/AspectJBuildManagerTest/lint.properties" ).getAbsolutePath(), + buildConfig.getLintSpecFile().toString()); + // and a few options thrown in at once + buildOptions.setNonStandardOptions( "-Xlint -XnoInline -XserializableAspects" ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + assertEquals( "Xlint", AjBuildConfig.AJLINT_DEFAULT, + buildConfig.getLintMode()); + assertTrue( "XnoInline", buildConfig.isXnoInline()); + assertTrue( "XserializableAspects", buildConfig.isXserializableAspects() ); + } + + public void testSourceRoots() { + Set roots = new HashSet(); + projectProperties.setSourceRoots( roots ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + List configRoots = buildConfig.getSourceRoots(); + assertTrue( "no source dirs", configRoots.isEmpty() ); + + File f = new File( "testdata/examples/figures/figures-coverage" ); + roots.add( f ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + List configRoots2 = buildConfig.getSourceRoots(); + assertTrue( "one source dir", configRoots2.size() == 1 ); + assertTrue( "source dir", configRoots2.contains(f) ); + + + File f2 = new File( "testdata/examples/figures/figures-demo" ); + roots.add( f2 ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + List configRoots3 = buildConfig.getSourceRoots(); + assertTrue( "two source dirs", configRoots3.size() == 2 ); + assertTrue( "source dir 1", configRoots3.contains(f) ); + assertTrue( "source dir 2", configRoots3.contains(f2) ); + } + + public void testInJars() { + Set jars = new HashSet(); + projectProperties.setInJars( jars ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + List inJars = buildConfig.getInJars(); + assertTrue( "no in jars", inJars.isEmpty() ); + + File f = new File( "jarone.jar" ); + jars.add( f ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + List inJars2 = buildConfig.getInJars(); + assertTrue( "one in jar", inJars2.size() == 1 ); + assertTrue( "in jar", inJars2.contains(f) ); + + + File f2 = new File( "jartwo.jar" ); + jars.add( f2 ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + List inJars3 = buildConfig.getInJars(); + assertTrue( "two in jars", inJars3.size() == 2 ); + assertTrue( "in jar 1", inJars3.contains(f) ); + assertTrue( "in jar 2", inJars3.contains(f2) ); + } + + public void testAspectPath() { + Set aspects = new HashSet(); + projectProperties.setAspectPath( aspects ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + List aPath = buildConfig.getAspectpath(); + assertTrue( "no aspect path", aPath.isEmpty() ); + + File f = new File( "jarone.jar" ); + aspects.add( f ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + List aPath2 = buildConfig.getAspectpath(); + assertTrue( "one jar in path", aPath2.size() == 1 ); + assertTrue( "1 aspectpath", aPath2.contains(f) ); + + + File f2 = new File( "jartwo.jar" ); + aspects.add( f2 ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + List aPath3 = buildConfig.getAspectpath(); + assertTrue( "two jars in path", aPath3.size() == 2 ); + assertTrue( "1 aspectpath", aPath3.contains(f) ); + assertTrue( "2 aspectpath", aPath3.contains(f2) ); + } + + public void testOutJar() { + String outJar = "mybuild.jar"; + projectProperties.setOutJar( outJar ); + buildConfig = compilerAdapter.genBuildConfig( configFile ); + assertEquals( "out jar", outJar, buildConfig.getOutputJar().toString() ); + } + + protected void setUp() throws Exception { + preferencesAdapter = new UserPreferencesStore(); + buildOptions = new AjcBuildOptions(preferencesAdapter); + compilerAdapter = new CompilerAdapter(); + projectProperties = new NullIdeProperties( "" ); + init(); + } + + protected void tearDown() throws Exception { + super.tearDown(); + buildOptions.setCharacterEncoding(""); + } + + public void init() { + try { + Ajde.init( + null, + null, + null, + projectProperties, + buildOptions, + null, + null, + null); + + //Ajde.getDefault().enableLogging( System.out ); + } catch (Throwable t) { + t.printStackTrace(); + Ajde.getDefault().getErrorHandler().handleError( + "Ajde failed to initialize.", + t); + } + } + + private void assertOptionEquals( String reason, Map options, String optionName, String value) { + String mapValue = (String) options.get(optionName); + assertEquals( reason, value, mapValue ); + } + +} diff --git a/ajde/testsrc/org/aspectj/ajde/BuildOptionsTest.java b/ajde/testsrc/org/aspectj/ajde/BuildOptionsTest.java index 5f5df1329..f30b4f308 100644 --- a/ajde/testsrc/org/aspectj/ajde/BuildOptionsTest.java +++ b/ajde/testsrc/org/aspectj/ajde/BuildOptionsTest.java @@ -8,11 +8,16 @@ * * Contributors: * Xerox/PARC initial implementation + * AMC 01.21.2003 extended to cover new AspectJ1.1 options * ******************************************************************/ package org.aspectj.ajde; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; + import junit.framework.TestSuite; import org.aspectj.ajde.ui.UserPreferencesAdapter; @@ -47,6 +52,97 @@ public class BuildOptionsTest extends AjdeTestCase { buildOptions.setPortingMode(true); assertTrue("porting mode", buildOptions.getPortingMode()); } + + public void testVerboseMode() { + buildOptions.setVerboseMode(true); + assertTrue("verbose mode", buildOptions.getVerboseMode()); + } + + public void testNonStandardOptions() { + buildOptions.setNonStandardOptions( "-Xlint" ); + assertEquals( "non std options", "-Xlint", + buildOptions.getNonStandardOptions()); + } + + public void testComplianceLevel() { + buildOptions.setComplianceLevel( BuildOptionsAdapter.VERSION_14 ); + assertEquals( "compliance level", + BuildOptionsAdapter.VERSION_14, + buildOptions.getComplianceLevel()); + } + + public void testSourceCompatibilityLevel() { + buildOptions.setSourceCompatibilityLevel(BuildOptionsAdapter.VERSION_13); + assertEquals( "source level", + BuildOptionsAdapter.VERSION_13, + buildOptions.getSourceCompatibilityLevel()); + } + + public void testWarnings() { + buildOptions.setWarnings( null ); + assertNull( "null warning set", buildOptions.getWarnings()); + HashSet s = new HashSet(); + buildOptions.setWarnings( s ); + Set s2 = buildOptions.getWarnings(); + assertTrue( "empty warning set", s2.isEmpty() ); + s.add( BuildOptionsAdapter.WARN_ASSERT_IDENITIFIER ); + s.add( BuildOptionsAdapter.WARN_MASKED_CATCH_BLOCKS ); + buildOptions.setWarnings( s ); + s2 = buildOptions.getWarnings(); + assertTrue( "two warnings", s2.size() == 2 ); + boolean warn_assert_found = false; + boolean warn_catch_found = false; + Iterator it = s2.iterator(); + while (it.hasNext()) { + String option = (String) it.next(); + if ( option.equals( BuildOptionsAdapter.WARN_ASSERT_IDENITIFIER ) ) { + warn_assert_found = true; + } + if ( option.equals( BuildOptionsAdapter.WARN_MASKED_CATCH_BLOCKS ) ) { + warn_catch_found = true; + } + } + assertTrue( "assert warning found", warn_assert_found ); + assertTrue( "catch waning found", warn_catch_found ); + } + + public void testDebugLevel() { + buildOptions.setDebugLevel( null ); + assertNull( "null debug set", buildOptions.getDebugLevel()); + HashSet s = new HashSet(); + buildOptions.setDebugLevel( s ); + Set s2 = buildOptions.getDebugLevel(); + assertTrue( "empty debug set", s2.isEmpty() ); + s.add( BuildOptionsAdapter.DEBUG_LINES ); + s.add( BuildOptionsAdapter.DEBUG_SOURCE ); + buildOptions.setDebugLevel( s ); + s2 = buildOptions.getDebugLevel(); + assertTrue( "two warnings", s2.size() == 2 ); + boolean debug_lines_found = false; + boolean debug_source_found = false; + Iterator it = s2.iterator(); + while (it.hasNext()) { + String option = (String) it.next(); + if ( option.equals( BuildOptionsAdapter.DEBUG_LINES ) ) { + debug_lines_found = true; + } + if ( option.equals( BuildOptionsAdapter.DEBUG_SOURCE ) ) { + debug_source_found = true; + } + } + assertTrue( "debug lines found", debug_lines_found ); + assertTrue( "debug source found", debug_source_found ); + } + + public void testNoImportError() { + buildOptions.setNoImportError(true); + assertTrue("no import error", buildOptions.getNoImportError()); + } + + public void testPreserveLocals() { + buildOptions.setPreserveAllLocals(true); + assertTrue("preserve all locals", buildOptions.getPreserveAllLocals()); + } protected void setUp() throws Exception { super.setUp(); diff --git a/ajde/testsrc/org/aspectj/ajde/NullIdeManager.java b/ajde/testsrc/org/aspectj/ajde/NullIdeManager.java index 2269fcaba..c3a09e8dc 100644 --- a/ajde/testsrc/org/aspectj/ajde/NullIdeManager.java +++ b/ajde/testsrc/org/aspectj/ajde/NullIdeManager.java @@ -44,6 +44,8 @@ public class NullIdeManager { new IconRegistry(), nullFrame, true); + + //Ajde.getDefault().enableLogging( System.out ); } catch (Throwable t) { t.printStackTrace(); Ajde.getDefault().getErrorHandler().handleError( diff --git a/ajde/testsrc/org/aspectj/ajde/NullIdeProperties.java b/ajde/testsrc/org/aspectj/ajde/NullIdeProperties.java index 0369954f8..03173f33b 100644 --- a/ajde/testsrc/org/aspectj/ajde/NullIdeProperties.java +++ b/ajde/testsrc/org/aspectj/ajde/NullIdeProperties.java @@ -8,6 +8,7 @@ * * Contributors: * Xerox/PARC initial implementation + * AMC 01.20.2003 extended to support AspectJ 1.1 options * ******************************************************************/ @@ -24,6 +25,11 @@ public class NullIdeProperties implements ProjectPropertiesAdapter { private String testProjectPath = ""; private List buildConfigFiles = new ArrayList(); + private Set inJars; + private Set sourceRoots; + private Set aspectPath; + private String outJar; + public NullIdeProperties(String testProjectPath) { this.testProjectPath = testProjectPath; } @@ -58,7 +64,10 @@ public class NullIdeProperties implements ProjectPropertiesAdapter { public String getClasspath() { //XXX - return testProjectPath + System.getProperty("sun.boot.class.path") + File.pathSeparator + "../../../runtime/bin"; + // AMC - added in path separator since absence was causing + // build failures with invalid classpath + return testProjectPath + File.pathSeparator + + System.getProperty("sun.boot.class.path") + File.pathSeparator + "../runtime/bin"; } public String getOutputPath() { @@ -84,4 +93,28 @@ public class NullIdeProperties implements ProjectPropertiesAdapter { public String getVmArgs() { return null; } + + public void setInJars( Set jars ) { this.inJars = jars; } + + public Set getInJars( ) { + return inJars; + } + + public void setOutJar( String jar ){ this.outJar = jar; } + + public String getOutJar() { + return outJar; + } + + public void setSourceRoots( Set roots ) { this.sourceRoots = roots; } + + public Set getSourceRoots() { + return sourceRoots; + } + + public void setAspectPath( Set path ) { this.aspectPath = path; } + + public Set getAspectPath() { + return aspectPath; + } } diff --git a/ajde/testsrc/org/aspectj/ajde/StructureModelRegressionTest.java b/ajde/testsrc/org/aspectj/ajde/StructureModelRegressionTest.java index be06bdf20..d3c4b1041 100644 --- a/ajde/testsrc/org/aspectj/ajde/StructureModelRegressionTest.java +++ b/ajde/testsrc/org/aspectj/ajde/StructureModelRegressionTest.java @@ -14,10 +14,12 @@ package org.aspectj.ajde; import java.io.File; +import java.util.List; import junit.framework.TestSuite; import org.aspectj.asm.StructureModel; +import org.aspectj.asm.StructureNode; public class StructureModelRegressionTest extends AjdeTestCase { @@ -36,7 +38,7 @@ public class StructureModelRegressionTest extends AjdeTestCase { } public void test() { - String testLstFile = "StructureModelRegressionTest/example.lst"; + String testLstFile = "testdata/StructureModelRegressionTest/example.lst"; File f = new File(testLstFile); assertTrue(testLstFile, f.canRead()); assertTrue("saved model: " + testLstFile, verifyAgainstSavedModel(testLstFile)); @@ -52,7 +54,14 @@ public class StructureModelRegressionTest extends AjdeTestCase { StructureModel savedModel = Ajde.getDefault().getStructureModelManager().getStructureModel(); //System.err.println( savedModel.getRoot().getClass() + ", " + savedModel.getRoot()); - return savedModel.getRoot().equals(model.getRoot()); + // AMC This test will not pass as written until StructureNode defines + // equals. The equals loic is commented out in the StructureNode + // class - adding it back in could have unforeseen system-wide + // consequences, so I've defined a structureNodesEqual( ) helper + // method here instead. + StructureNode rootNode = model.getRoot(); + StructureNode savedRootNode = savedModel.getRoot(); + return structureNodesEqual( rootNode, savedRootNode ); } else { Ajde.getDefault().getStructureModelManager().writeStructureModel(lstFile); return true; @@ -60,6 +69,30 @@ public class StructureModelRegressionTest extends AjdeTestCase { //return true; } + private boolean structureNodesEqual( StructureNode s1, StructureNode s2 ) { + final boolean equal = true; + if ( s1 == s2 ) return equal; + if ( null == s1 || null == s2 ) return !equal; + + if (!s1.getName( ).equals(s2.getName())) return !equal; + if (!s1.getKind( ).equals(s2.getKind())) return !equal; + + // check child nodes + List s1Kids = s1.getChildren(); + List s2Kids = s2.getChildren(); + + if ( s1Kids != null && s2Kids != null ) { + if (s1Kids == null || s2Kids == null) return !equal; + if (s1Kids.size() != s2Kids.size() ) return !equal; + for ( int k=0; k<s1Kids.size(); k++ ) { + StructureNode k1 = (StructureNode) s1Kids.get(k); + StructureNode k2 = (StructureNode) s2Kids.get(k); + if (!structureNodesEqual( k1, k2 )) return !equal; + } + } + return equal; + } + private StructureModel getModelForFile(String lstFile) { Ajde.getDefault().getConfigurationManager().setActiveConfigFile(lstFile); Ajde.getDefault().getBuildManager().buildStructure(); diff --git a/ajde/testsrc/org/aspectj/ajde/StructureModelTest.java b/ajde/testsrc/org/aspectj/ajde/StructureModelTest.java index 244a26b25..cd3e3db57 100644 --- a/ajde/testsrc/org/aspectj/ajde/StructureModelTest.java +++ b/ajde/testsrc/org/aspectj/ajde/StructureModelTest.java @@ -8,6 +8,7 @@ * * Contributors: * Xerox/PARC initial implementation + * AMC 21.01.2003 fixed for new source location in eclipse.org * ******************************************************************/ package org.aspectj.ajde; @@ -43,7 +44,7 @@ public class StructureModelTest extends AjdeTestCase { } public void testFieldInitializerCorrespondence() throws IOException { - File testFile = createFile("../examples/figures-coverage/figures/Figure.java"); + File testFile = createFile("testdata/examples/figures-coverage/figures/Figure.java"); StructureNode node = Ajde.getDefault().getStructureModelManager().getStructureModel().findNodeForSourceLine( testFile.getCanonicalPath(), 28); assertTrue("find result", node != null) ; @@ -65,7 +66,7 @@ public class StructureModelTest extends AjdeTestCase { assertTrue("find associated node", foundNode != null) ; - File pointFile = createFile("../examples/figures-coverage/figures/primitives/planar/Point.java"); + File pointFile = createFile("testdata/examples/figures-coverage/figures/primitives/planar/Point.java"); StructureNode fieldNode = Ajde.getDefault().getStructureModelManager().getStructureModel().findNodeForSourceLine( pointFile.getCanonicalPath(), 12); assertTrue("find result", fieldNode != null); @@ -74,7 +75,7 @@ public class StructureModelTest extends AjdeTestCase { } public void testFileNodeFind() throws IOException { - File testFile = createFile("../examples/figures-coverage/figures/Main.java"); + File testFile = createFile("testdata/examples/figures-coverage/figures/Main.java"); StructureNode node = Ajde.getDefault().getStructureModelManager().getStructureModel().findNodeForSourceLine( testFile.getCanonicalPath(), 1); assertTrue("find result", node != null) ; @@ -87,7 +88,7 @@ public class StructureModelTest extends AjdeTestCase { */ public void testMainClassNodeInfo() throws IOException { assertTrue("root exists", Ajde.getDefault().getStructureModelManager().getStructureModel().getRoot() != null); - File testFile = createFile("../examples/figures-coverage/figures/Main.java"); + File testFile = createFile("testdata/examples/figures-coverage/figures/Main.java"); StructureNode node = Ajde.getDefault().getStructureModelManager().getStructureModel().findNodeForSourceLine( testFile.getCanonicalPath(), 11); assertTrue("find result", node != null); diff --git a/ajde/testsrc/org/aspectj/ajde/ui/StructureViewManagerTest.java b/ajde/testsrc/org/aspectj/ajde/ui/StructureViewManagerTest.java index e6b7f8ae9..4c3351f57 100644 --- a/ajde/testsrc/org/aspectj/ajde/ui/StructureViewManagerTest.java +++ b/ajde/testsrc/org/aspectj/ajde/ui/StructureViewManagerTest.java @@ -83,6 +83,7 @@ public class StructureViewManagerTest extends AjdeTestCase { assertTrue("notified", renderer.getHasBeenNotified()); //System.err.println(">>>>>> " + currentView.getRootNode().getStructureNode()); + StructureNode n = currentView.getRootNode().getStructureNode(); assertTrue( "no structure", currentView.getRootNode().getStructureNode().getChildren().get(0) diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/ajc/BuildArgParser.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/ajc/BuildArgParser.java index 99c2dc8ac..4df6f257e 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/ajc/BuildArgParser.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/ajc/BuildArgParser.java @@ -355,7 +355,9 @@ public class BuildArgParser extends org.eclipse.jdt.internal.compiler.batch.Main } else if (arg.equals("-emacssym")) { buildConfig.setEmacsSymMode(true); buildConfig.setGenerateModelMode(true); - } else if (arg.equals("-noweave")) { + //AMC - added -XnoWeave to options that match, in line with + // AspectJ 1.1 release notes documentation. + } else if (arg.equals("-noweave") || arg.equals( "-XnoWeave")) { buildConfig.setNoWeave(true); } else if (arg.equals("-XserializableAspects")) { buildConfig.setXserializableAspects(true); diff --git a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/core/builder/AjBuildConfig.java b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/core/builder/AjBuildConfig.java index 60089d65c..301fd1bae 100644 --- a/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/core/builder/AjBuildConfig.java +++ b/org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/core/builder/AjBuildConfig.java @@ -8,6 +8,9 @@ * * Contributors: * PARC initial implementation + * Adrian Colyer added constructor to populate javaOptions with + * default settings - 01.20.2003 + * Bugzilla #29768, 29769 * ******************************************************************/ @@ -16,12 +19,14 @@ package org.aspectj.ajdt.internal.core.builder; import java.io.File; import java.util.*; +import org.eclipse.jdt.internal.compiler.impl.CompilerOptions; + /** * All configuration information needed to run the AspectJ compiler. */ public class AjBuildConfig { - public static final String AJLINT_INGORE = "ignore"; + public static final String AJLINT_IGNORE = "ignore"; public static final String AJLINT_WARN = "warn"; public static final String AJLINT_ERROR = "error"; public static final String AJLINT_DEFAULT = "default"; @@ -45,6 +50,72 @@ public class AjBuildConfig { private File lintSpecFile = null; /** + * Intialises the javaOptions Map to hold the default + * JDT Compiler settings. Added by AMC 01.20.2003 in reponse + * to bug #29768 and enh. 29769. + * The settings here are duplicated from those set in + * org.eclipse.jdt.internal.compiler.batch.Main, but I've elected to + * copy them rather than refactor the JDT class since this keeps + * integration with future JDT releases easier (?). + */ + public AjBuildConfig( ) { + javaOptions.put( + CompilerOptions.OPTION_LocalVariableAttribute, + CompilerOptions.DO_NOT_GENERATE); + javaOptions.put( + CompilerOptions.OPTION_LineNumberAttribute, + CompilerOptions.DO_NOT_GENERATE); + javaOptions.put( + CompilerOptions.OPTION_SourceFileAttribute, + CompilerOptions.DO_NOT_GENERATE); + javaOptions.put( + CompilerOptions.OPTION_PreserveUnusedLocal, + CompilerOptions.OPTIMIZE_OUT); + javaOptions.put( + CompilerOptions.OPTION_ReportUnreachableCode, + CompilerOptions.ERROR); + javaOptions.put( + CompilerOptions.OPTION_ReportInvalidImport, + CompilerOptions.ERROR); + javaOptions.put( + CompilerOptions.OPTION_ReportOverridingPackageDefaultMethod, + CompilerOptions.WARNING); + javaOptions.put( + CompilerOptions.OPTION_ReportMethodWithConstructorName, + CompilerOptions.WARNING); + javaOptions.put( + CompilerOptions.OPTION_ReportDeprecation, + CompilerOptions.WARNING); + javaOptions.put( + CompilerOptions.OPTION_ReportHiddenCatchBlock, + CompilerOptions.WARNING); + javaOptions.put( + CompilerOptions.OPTION_ReportUnusedLocal, + CompilerOptions.IGNORE); + javaOptions.put( + CompilerOptions.OPTION_ReportUnusedParameter, + CompilerOptions.IGNORE); + javaOptions.put( + CompilerOptions.OPTION_ReportSyntheticAccessEmulation, + CompilerOptions.IGNORE); + javaOptions.put( + CompilerOptions.OPTION_ReportNonExternalizedStringLiteral, + CompilerOptions.IGNORE); + javaOptions.put( + CompilerOptions.OPTION_ReportAssertIdentifier, + CompilerOptions.IGNORE); + javaOptions.put( + CompilerOptions.OPTION_Compliance, + CompilerOptions.VERSION_1_3); + javaOptions.put( + CompilerOptions.OPTION_Source, + CompilerOptions.VERSION_1_3); + javaOptions.put( + CompilerOptions.OPTION_TargetPlatform, + CompilerOptions.VERSION_1_1); + } + + /** * returned files includes <ul> * <li>files explicitly listed on command-line</li> * <li>files listed by reference in argument list files</li> diff --git a/org.aspectj.ajdt.core/testsrc/org/aspectj/ajdt/ajc/BuildArgParserTestCase.java b/org.aspectj.ajdt.core/testsrc/org/aspectj/ajdt/ajc/BuildArgParserTestCase.java index badb55691..c9e8f7152 100644 --- a/org.aspectj.ajdt.core/testsrc/org/aspectj/ajdt/ajc/BuildArgParserTestCase.java +++ b/org.aspectj.ajdt.core/testsrc/org/aspectj/ajdt/ajc/BuildArgParserTestCase.java @@ -335,7 +335,7 @@ public class BuildArgParserTestCase extends TestCase { config = parser.genBuildConfig(new String[] {"-Xlint:error"}, messageWriter); assertTrue("", config.getLintMode().equals(AjBuildConfig.AJLINT_ERROR)); config = parser.genBuildConfig(new String[] {"-Xlint:ignore"}, messageWriter); - assertTrue("", config.getLintMode().equals(AjBuildConfig.AJLINT_INGORE)); + assertTrue("", config.getLintMode().equals(AjBuildConfig.AJLINT_IGNORE)); } public void testXlintfile() throws InvalidInputException { |