class ScalaCompile(JvmCompile): _language = 'scala' _file_suffix = '.scala' _config_section = 'scala-compile' @classmethod def setup_parser(cls, option_group, args, mkflag): super(ScalaCompile, cls).setup_parser(option_group, args, mkflag) option_group.add_option( mkflag('plugins'), dest='plugins', default=None, action='append', help='Use these scalac plugins. Default is set in pants.ini.') def __init__(self, *args, **kwargs): super(ScalaCompile, self).__init__(*args, **kwargs) # Set up the zinc utils. color = not self.context.options.no_color self._zinc_utils = ZincUtils(context=self.context, nailgun_task=self, jvm_options=self._jvm_options, color=color) self.configure_args( args_defaults=_SCALA_COMPILE_ARGS_DEFAULT, warning_defaults=_SCALA_COMPILE_WARNING_ARGS_DEFAULT, no_warning_defaults=_SCALA_COMPILE_WARNING_ARGS_DEFAULT) @property def config_section(self): return self._config_section def create_analysis_tools(self): return AnalysisTools(self.context, ZincAnalysisParser(self._classes_dir), ZincAnalysis) def extra_compile_time_classpath_elements(self): # Classpath entries necessary for our compiler plugins. return self._zinc_utils.plugin_jars() # Invalidate caches if the toolchain changes. def platform_version_info(self): zinc_invalidation_key = self._zinc_utils.platform_version_info() jvm_target_version = '' # Check scalac args for jvm target version. for arg in self._args: if arg.strip().startswith("-S-target:"): jvm_target_version = arg.strip() zinc_invalidation_key.append(jvm_target_version) return zinc_invalidation_key def extra_products(self, target): ret = [] if target.is_scalac_plugin and target.classname: root, plugin_info_file = ZincUtils.write_plugin_info( self._resources_dir, target) ret.append((root, [plugin_info_file])) return ret def compile(self, args, classpath, sources, classes_output_dir, analysis_file): # We have to treat our output dir as an upstream element, so zinc can find valid # analysis for previous partitions. We use the global valid analysis for the upstream. upstream = ({ classes_output_dir: self._analysis_file } if os.path.exists(self._analysis_file) else {}) return self._zinc_utils.compile(args, classpath + [self._classes_dir], sources, classes_output_dir, analysis_file, upstream)
class ScalaCompile(JvmCompile): _language = 'scala' _file_suffix = '.scala' @classmethod def get_args_default(cls, bootstrap_option_values): return ('-S-encoding', '-SUTF-8','-S-g:vars') @classmethod def get_warning_args_default(cls): return ('-S-deprecation', '-S-unchecked') @classmethod def get_no_warning_args_default(cls): return ('-S-nowarn',) @classmethod def register_options(cls, register): super(ScalaCompile, cls).register_options(register) # Note: Used in ZincUtils. # TODO: Revisit this. It's unintuitive for ZincUtils to reach back into the task for options. register('--plugins', action='append', help='Use these scalac plugins.') ZincUtils.register_options(register, cls.register_jvm_tool) def __init__(self, *args, **kwargs): super(ScalaCompile, self).__init__(*args, **kwargs) # Set up the zinc utils. color = not self.get_options().no_colors self._zinc_utils = ZincUtils(context=self.context, nailgun_task=self, jvm_options=self._jvm_options, color=color, log_level=self.get_options().level) def create_analysis_tools(self): return AnalysisTools(self.context.java_home, self.ivy_cache_dir, ZincAnalysisParser(self._classes_dir), ZincAnalysis) def extra_compile_time_classpath_elements(self): # Classpath entries necessary for our compiler plugins. return self._zinc_utils.plugin_jars() # Invalidate caches if the toolchain changes. def platform_version_info(self): zinc_invalidation_key = self._zinc_utils.platform_version_info() jvm_target_version = '' # Check scalac args for jvm target version. for arg in self._args: if arg.strip().startswith("-S-target:"): jvm_target_version = arg.strip() zinc_invalidation_key.append(jvm_target_version) return zinc_invalidation_key def extra_products(self, target): ret = [] if target.is_scalac_plugin and target.classname: root, plugin_info_file = ZincUtils.write_plugin_info(self._resources_dir, target) ret.append((root, [plugin_info_file])) return ret def compile(self, args, classpath, sources, classes_output_dir, analysis_file): # We have to treat our output dir as an upstream element, so zinc can find valid # analysis for previous partitions. We use the global valid analysis for the upstream. upstream = ({classes_output_dir: self._analysis_file} if os.path.exists(self._analysis_file) else {}) return self._zinc_utils.compile(args, classpath + [self._classes_dir], sources, classes_output_dir, analysis_file, upstream)
class ScalaCompile(JvmCompile): _language = 'scala' _file_suffix = '.scala' _config_section = 'scala-compile' @classmethod def setup_parser(cls, option_group, args, mkflag): super(ScalaCompile, cls).setup_parser(option_group, args, mkflag) option_group.add_option(mkflag('plugins'), dest='plugins', default=None, action='append', help='Use these scalac plugins. Default is set in pants.ini.') def __init__(self, *args, **kwargs): super(ScalaCompile, self).__init__(*args, **kwargs) # Set up the zinc utils. color = not self.context.options.no_color self._zinc_utils = ZincUtils(context=self.context, nailgun_task=self, jvm_options=self._jvm_options, color=color) self.configure_args(args_defaults=_SCALA_COMPILE_ARGS_DEFAULT, warning_defaults=_SCALA_COMPILE_WARNING_ARGS_DEFAULT, no_warning_defaults=_SCALA_COMPILE_WARNING_ARGS_DEFAULT) @property def config_section(self): return self._config_section def create_analysis_tools(self): return AnalysisTools(self.context, ZincAnalysisParser(self._classes_dir), ZincAnalysis) def extra_compile_time_classpath_elements(self): # Classpath entries necessary for our compiler plugins. return self._zinc_utils.plugin_jars() # Invalidate caches if the toolchain changes. def platform_version_info(self): zinc_invalidation_key = self._zinc_utils.platform_version_info() jvm_target_version = '' # Check scalac args for jvm target version. for arg in self._args: if arg.strip().startswith("-S-target:"): jvm_target_version = arg.strip() zinc_invalidation_key.append(jvm_target_version) return zinc_invalidation_key def extra_products(self, target): ret = [] if target.is_scalac_plugin and target.classname: root, plugin_info_file = ZincUtils.write_plugin_info(self._resources_dir, target) ret.append((root, [plugin_info_file])) return ret def compile(self, args, classpath, sources, classes_output_dir, analysis_file): # We have to treat our output dir as an upstream element, so zinc can find valid # analysis for previous partitions. We use the global valid analysis for the upstream. upstream = ({classes_output_dir: self._analysis_file} if os.path.exists(self._analysis_file) else {}) return self._zinc_utils.compile(args, classpath + [self._classes_dir], sources, classes_output_dir, analysis_file, upstream)
class ScalaCompile(JvmCompile): _language = 'scala' _file_suffix = '.scala' @classmethod def get_args_default(cls, bootstrap_option_values): return ('-S-encoding', '-SUTF-8', '-S-g:vars') @classmethod def get_warning_args_default(cls): return ('-S-deprecation', '-S-unchecked') @classmethod def get_no_warning_args_default(cls): return ('-S-nowarn', ) @classmethod def register_options(cls, register): super(ScalaCompile, cls).register_options(register) # Note: Used in ZincUtils. # TODO: Revisit this. It's unintuitive for ZincUtils to reach back into the task for options. register('--plugins', action='append', help='Use these scalac plugins.') register('--name-hashing', action='store_true', default=False, help='Use zinc name hashing.') ZincUtils.register_options(register, cls.register_jvm_tool) def __init__(self, *args, **kwargs): super(ScalaCompile, self).__init__(*args, **kwargs) # Set up the zinc utils. color = self.get_options().colors self._zinc_utils = ZincUtils(context=self.context, nailgun_task=self, jvm_options=self._jvm_options, color=color, log_level=self.get_options().level) def create_analysis_tools(self): return AnalysisTools(self.context.java_home, self.ivy_cache_dir, ZincAnalysisParser(self._classes_dir), ZincAnalysis) def extra_compile_time_classpath_elements(self): # Classpath entries necessary for our compiler plugins. return self._zinc_utils.plugin_jars() # Invalidate caches if the toolchain changes. def platform_version_info(self): zinc_invalidation_key = self._zinc_utils.platform_version_info() jvm_target_version = '' # Check scalac args for jvm target version. for arg in self._args: if arg.strip().startswith("-S-target:"): jvm_target_version = arg.strip() zinc_invalidation_key.append(jvm_target_version) return zinc_invalidation_key def extra_products(self, target): ret = [] if target.is_scalac_plugin and target.classname: root, plugin_info_file = ZincUtils.write_plugin_info( self._resources_dir, target) ret.append((root, [plugin_info_file])) return ret def compile(self, args, classpath, sources, classes_output_dir, analysis_file): # We have to treat our output dir as an upstream element, so zinc can find valid # analysis for previous partitions. We use the global valid analysis for the upstream. upstream = ({ classes_output_dir: self._analysis_file } if os.path.exists(self._analysis_file) else {}) return self._zinc_utils.compile(args, classpath + [self._classes_dir], sources, classes_output_dir, analysis_file, upstream)
class ScalaCompile(JvmCompile): _language = 'scala' _file_suffix = '.scala' @classmethod def get_args_default(cls, bootstrap_option_values): return ('-S-encoding', '-SUTF-8','-S-g:vars') @classmethod def get_warning_args_default(cls): return ('-S-deprecation', '-S-unchecked') @classmethod def get_no_warning_args_default(cls): return ('-S-nowarn',) @classmethod def register_options(cls, register): super(ScalaCompile, cls).register_options(register) # Note: Used in ZincUtils. # TODO: Revisit this. It's unintuitive for ZincUtils to reach back into the task for options. register('--plugins', action='append', help='Use these scalac plugins.') register('--plugin-args', advanced=True, type=Options.dict, default={}, help='Map from plugin name to list of arguments for that plugin.') register('--name-hashing', action='store_true', default=False, help='Use zinc name hashing.') ZincUtils.register_options(register, cls.register_jvm_tool) def __init__(self, *args, **kwargs): super(ScalaCompile, self).__init__(*args, **kwargs) # Set up the zinc utils. color = self.get_options().colors self._zinc_utils = ZincUtils(context=self.context, nailgun_task=self, jvm_options=self._jvm_options, color=color, log_level=self.get_options().level) # A directory independent of any other classpath which can contain per-target # plugin resource files. self._plugin_info_dir = os.path.join(self.workdir, 'scalac-plugin-info') def create_analysis_tools(self): return AnalysisTools(self.context.java_home, ZincAnalysisParser(), ZincAnalysis) def extra_compile_time_classpath_elements(self): # Classpath entries necessary for our compiler plugins. return self._zinc_utils.plugin_jars() # Invalidate caches if the toolchain changes. def _language_platform_version_info(self): zinc_invalidation_key = self._zinc_utils.platform_version_info() # Invalidate if any compiler args change. # Note that while some args are obviously important for invalidation (e.g., the jvm target # version), some might not be. However we must invalidated on all the args, because Zinc # ignores analysis files if the compiler args they were created with are different from the # current ones, and does a full recompile. So if we allow cached artifacts with those analysis # files to be used, Zinc will do unnecessary full recompiles on subsequent edits. zinc_invalidation_key.extend(self._args) # Invalidate if use of name hashing changes. zinc_invalidation_key.append( 'name-hashing-{0}'.format('on' if self.get_options().name_hashing else 'off')) return zinc_invalidation_key def extra_products(self, target): """Override extra_products to produce a plugin information file.""" ret = [] if target.is_scalac_plugin and target.classname: # NB: We don't yet support explicit in-line compilation of scala compiler plugins from # the workspace to be used in subsequent compile rounds like we do for annotation processors # with javac. This would require another GroupTask similar to AptCompile, but for scala. root, plugin_info_file = ZincUtils.write_plugin_info(self._plugin_info_dir, target) ret.append((root, [plugin_info_file])) return ret def compile(self, args, classpath, sources, classes_output_dir, upstream_analysis, analysis_file): return self._zinc_utils.compile(args, classpath, sources, classes_output_dir, analysis_file, upstream_analysis)