Java Code Examples for org.eclipse.xtext.util.internal.Stopwatches#forTask()

@Override
public IResolvedTypes reentrantResolve(CancelIndicator monitor) {
	if (resolving) {
		throw new UnsupportedOperationException("TODO: import a functional handle on the type resolution that delegates to the best available (current, but evolving) result");
	}
	StoppedTask task = Stopwatches.forTask("DefaultReentrantTypeResolver.resolve");
	try {
		task.start();
		resolving = true;
		return resolve(monitor);
	} catch(Throwable e) {
		clear();
		if (operationCanceledManager.isOperationCanceledException(e)) {
			operationCanceledManager.propagateAsErrorIfCancelException(e);
		}
		Throwables.throwIfUnchecked(e);
		throw new RuntimeException(e);
	} finally {
		resolving = false;
		task.stop();
	}
}
 

@Override
public List<Issue> validate(Resource resource, final CheckMode mode, CancelIndicator mon) throws OperationCanceledError {
	StoppedTask task = Stopwatches.forTask("ResourceValidatorImpl.validation");
	try {
		task.start();
		final CancelIndicator monitor = mon == null ? CancelIndicator.NullImpl : mon;
		resolveProxies(resource, monitor);
		operationCanceledManager.checkCanceled(monitor);

		final List<Issue> result = Lists.newArrayListWithExpectedSize(resource.getErrors().size()
				+ resource.getWarnings().size());
		try {
			IAcceptor<Issue> acceptor = createAcceptor(result);

			if (mode.shouldCheck(CheckType.FAST)) {
				collectResourceDiagnostics(resource, monitor, acceptor);
			}

			operationCanceledManager.checkCanceled(monitor);
			boolean syntaxDiagFail = !result.isEmpty();
			logCheckStatus(resource, syntaxDiagFail, "Syntax");

			validate(resource, mode, monitor, acceptor);
			operationCanceledManager.checkCanceled(monitor);
		} catch (RuntimeException e) {
			operationCanceledManager.propagateAsErrorIfCancelException(e);
			log.error(e.getMessage(), e);
		}
		return result;
	} finally {
		task.stop();
	}
}
 

@Override
public final IParseResult parse(Reader reader) {
	StoppedTask task = Stopwatches.forTask("AbstractParser.parse");
	try {
		task.start();
		return doParse(reader);
	} finally {
		task.stop();
	}
}
 

public void loadFromStorage(ResourceStorageLoadable storageInputStream) throws IOException {
	// check the argument for null before the internal state is modified
	Preconditions.checkNotNull(storageInputStream, "storageInputStream");
	Stopwatches.StoppedTask task = Stopwatches.forTask("Loading from storage");
	task.start();
	isLoading = true;
	isLoadedFromStorage = true;
	try {
		storageInputStream.loadIntoResource(this);
		isLoaded = true;
	} finally {
		isLoading = false;
		task.stop();
	}
}
 

@Override
public void buildFinished(IJavaProject project) {
	StoppedTask task = Stopwatches.forTask("DebugSourceInstallingCompilationParticipant.install");
	try {
		task.start();
		super.buildFinished(project);
		if (files == null)
			return;
		for (BuildContext ctx : files) {
			try {
				IFile generatedJavaFile = ctx.getFile();

				// This may fail if there is no trace file.
				IEclipseTrace traceToSource = traceInformation.getTraceToSource(generatedJavaFile);
				if (traceToSource == null) {
					continue;
				}
				AbstractTraceRegion rootTraceRegion = findRootTraceRegion(traceToSource);
				if (rootTraceRegion == null)
					continue;

				SourceRelativeURI dslSourceFile = rootTraceRegion.getAssociatedSrcRelativePath();

				// OutputConfigurations are only available for folders targeted by Xtext's code generation.
				OutputConfiguration outputConfiguration = findOutputConfiguration(dslSourceFile, generatedJavaFile);
				if (outputConfiguration == null)
					continue;

				IJavaElement element = JavaCore.create(generatedJavaFile);
				if (element == null)
					continue;

				deleteTaskMarkers(generatedJavaFile);
				markerReflector.reflectErrorMarkerInSource(generatedJavaFile, traceToSource);

				ITraceToBytecodeInstaller installer = getInstaller(outputConfiguration);
				installer.setTrace(generatedJavaFile.getName(), rootTraceRegion);
				for (IFile javaClassFile : findGeneratedJavaClassFiles(element)) {
					InputStream contents = javaClassFile.getContents();
					try {
						byte[] byteCode = installer.installTrace(ByteStreams.toByteArray(contents));
						if (byteCode != null) {
							javaClassFile.setContents(new ByteArrayInputStream(byteCode), 0, null);
						} else {
							// we need to touch the class file to do a respin of the build
							// otherwise a needsRebuild request is ignored since no IResourceDelta is available
							javaClassFile.touch(null);
						}
					} finally {
						contents.close();
					}
				}
			} catch (Exception e) {
				String msg = "Could not process %s to install source information: %s";
				log.error(String.format(msg, ctx.getFile().getFullPath().toString(), e.getMessage()), e);
			}
		}
	} finally {
		files = null;
		task.stop();
	}
}
 

@Override
public void build(final IBuildContext context, IProgressMonitor monitor) throws CoreException {
	if (!isEnabled(context)) {
		return;
	}

	final List<IResourceDescription.Delta> deltas = getRelevantDeltas(context);
	if (deltas.isEmpty()) {
		return;
	}
	
	StoppedTask task = Stopwatches.forTask("org.eclipse.xtext.builder.BuilderParticipant.build(IBuildContext, IProgressMonitor)");
	try {
		task.start();
		
		// monitor handling
		if (monitor.isCanceled())
			throw new OperationCanceledException();
		SubMonitor subMonitor = SubMonitor.convert(monitor, context.getBuildType() == BuildType.RECOVERY ? 5 : 3);

		EclipseResourceFileSystemAccess2 access = fileSystemAccessProvider.get();
		IProject builtProject = context.getBuiltProject();
		access.setProject(builtProject);
		Map<String, OutputConfiguration> outputConfigurations = getOutputConfigurations(context);
		refreshOutputFolders(context, outputConfigurations, subMonitor.split(1));
		if (subMonitor.isCanceled()) {
			throw new OperationCanceledException();
		}
		access.setOutputConfigurations(outputConfigurations);
		if (context.getBuildType() == BuildType.CLEAN || context.getBuildType() == BuildType.RECOVERY) {
			SubMonitor cleanMonitor = SubMonitor.convert(subMonitor.newChild(2), outputConfigurations.size());
			for (OutputConfiguration config : outputConfigurations.values()) {
				cleanOutput(context, config, access, cleanMonitor.newChild(1));
			}
			if (context.getBuildType() == BuildType.CLEAN)
				return;
		}
		Map<OutputConfiguration, Iterable<IMarker>> generatorMarkers = getGeneratorMarkers(builtProject, outputConfigurations.values());
		if (subMonitor.isCanceled()) {
			throw new OperationCanceledException();
		}
		doBuild(deltas, outputConfigurations, generatorMarkers, context, access, subMonitor.newChild(2));

	} finally {
		outputConfigurationCache.clear();
		task.stop();
	}
}
 

/**
 * gets called from Xtend compiler, during "model inference", i.e. translation of Xtend AST to Java AST
 */
public Object indexingPhase(final ActiveAnnotationContext ctx, final IJvmDeclaredTypeAcceptor acceptor, final CancelIndicator monitor) {
  Object _xblockexpression = null;
  {
    final Stopwatches.StoppedTask task = Stopwatches.forTask("[macros] indexingPhase (AnnotationProcessor.indexingPhase)");
    task.start();
    Object _xtrycatchfinallyexpression = null;
    try {
      Object _switchResult = null;
      Object _processorInstance = ctx.getProcessorInstance();
      final Object processor = _processorInstance;
      boolean _matched = false;
      if (processor instanceof RegisterGlobalsParticipant) {
        _matched=true;
        Object _xblockexpression_1 = null;
        {
          final RegisterGlobalsContextImpl registerGlobalsCtx = this.registerGlobalsContextProvider.get();
          registerGlobalsCtx.setAcceptor(acceptor);
          registerGlobalsCtx.setCompilationUnit(ctx.getCompilationUnit());
          final Runnable _function = () -> {
            final Function1<XtendAnnotationTarget, Declaration> _function_1 = (XtendAnnotationTarget it) -> {
              Declaration _switchResult_1 = null;
              boolean _matched_1 = false;
              if (it instanceof XtendMember) {
                _matched_1=true;
                _switchResult_1 = ctx.getCompilationUnit().toXtendMemberDeclaration(((XtendMember)it));
              }
              if (!_matched_1) {
                if (it instanceof XtendParameter) {
                  _matched_1=true;
                  _switchResult_1 = ctx.getCompilationUnit().toXtendParameterDeclaration(((XtendParameter)it));
                }
              }
              final Declaration xtendMember = _switchResult_1;
              return xtendMember;
            };
            ((RegisterGlobalsParticipant<NamedElement>)processor).doRegisterGlobals(
              ListExtensions.<XtendAnnotationTarget, Declaration>map(ctx.getAnnotatedSourceElements(), _function_1), registerGlobalsCtx);
          };
          _xblockexpression_1 = this.runWithCancelIndiciator(ctx, monitor, _function);
        }
        _switchResult = _xblockexpression_1;
      }
      _xtrycatchfinallyexpression = _switchResult;
    } finally {
      task.stop();
    }
    _xblockexpression = _xtrycatchfinallyexpression;
  }
  return _xblockexpression;
}
 

public Object inferencePhase(final ActiveAnnotationContext ctx, final CancelIndicator monitor) {
  Object _xblockexpression = null;
  {
    final Stopwatches.StoppedTask task = Stopwatches.forTask("[macros] inferencePhase (AnnotationProcessor.inferencePhase)");
    task.start();
    Object _xtrycatchfinallyexpression = null;
    try {
      Object _switchResult = null;
      Object _processorInstance = ctx.getProcessorInstance();
      final Object processor = _processorInstance;
      boolean _matched = false;
      if (processor instanceof TransformationParticipant) {
        _matched=true;
        Object _xblockexpression_1 = null;
        {
          final TransformationContextImpl modifyCtx = this.modifyContextProvider.get();
          modifyCtx.setUnit(ctx.getCompilationUnit());
          final Runnable _function = () -> {
            final Function1<XtendAnnotationTarget, MutableNamedElement> _function_1 = (XtendAnnotationTarget it) -> {
              Declaration _switchResult_1 = null;
              boolean _matched_1 = false;
              if (it instanceof XtendMember) {
                _matched_1=true;
                _switchResult_1 = ctx.getCompilationUnit().toXtendMemberDeclaration(((XtendMember)it));
              }
              if (!_matched_1) {
                if (it instanceof XtendParameter) {
                  _matched_1=true;
                  _switchResult_1 = ctx.getCompilationUnit().toXtendParameterDeclaration(((XtendParameter)it));
                }
              }
              final Declaration xtendMember = _switchResult_1;
              Element _primaryGeneratedJavaElement = modifyCtx.getPrimaryGeneratedJavaElement(xtendMember);
              return ((MutableNamedElement) _primaryGeneratedJavaElement);
            };
            final List<MutableNamedElement> map = ListExtensions.<XtendAnnotationTarget, MutableNamedElement>map(ctx.getAnnotatedSourceElements(), _function_1);
            ((TransformationParticipant<MutableNamedElement>)processor).doTransform(map, modifyCtx);
          };
          _xblockexpression_1 = this.runWithCancelIndiciator(ctx, monitor, _function);
        }
        _switchResult = _xblockexpression_1;
      }
      _xtrycatchfinallyexpression = _switchResult;
    } finally {
      task.stop();
    }
    _xblockexpression = _xtrycatchfinallyexpression;
  }
  return _xblockexpression;
}
 

public Object validationPhase(final ActiveAnnotationContext ctx, final CancelIndicator monitor) {
  Object _xblockexpression = null;
  {
    final Stopwatches.StoppedTask task = Stopwatches.forTask("[macros] validationPhase (AnnotationProcessor.validationPhase)");
    task.start();
    Object _xtrycatchfinallyexpression = null;
    try {
      Object _switchResult = null;
      Object _processorInstance = ctx.getProcessorInstance();
      final Object processor = _processorInstance;
      boolean _matched = false;
      if (processor instanceof ValidationParticipant) {
        _matched=true;
        Object _xblockexpression_1 = null;
        {
          final ValidationContextImpl validationContext = this.validationContextProvider.get();
          validationContext.setUnit(ctx.getCompilationUnit());
          final Runnable _function = () -> {
            final Function1<XtendAnnotationTarget, NamedElement> _function_1 = (XtendAnnotationTarget it) -> {
              Declaration _switchResult_1 = null;
              boolean _matched_1 = false;
              if (it instanceof XtendMember) {
                _matched_1=true;
                _switchResult_1 = ctx.getCompilationUnit().toXtendMemberDeclaration(((XtendMember)it));
              }
              if (!_matched_1) {
                if (it instanceof XtendParameter) {
                  _matched_1=true;
                  _switchResult_1 = ctx.getCompilationUnit().toXtendParameterDeclaration(((XtendParameter)it));
                }
              }
              final Declaration xtendMember = _switchResult_1;
              Element _primaryGeneratedJavaElement = validationContext.getPrimaryGeneratedJavaElement(xtendMember);
              return ((NamedElement) _primaryGeneratedJavaElement);
            };
            final List<NamedElement> map = ListExtensions.<XtendAnnotationTarget, NamedElement>map(ctx.getAnnotatedSourceElements(), _function_1);
            ((ValidationParticipant<NamedElement>)processor).doValidate(map, validationContext);
          };
          _xblockexpression_1 = this.runWithCancelIndiciator(ctx, monitor, _function);
        }
        _switchResult = _xblockexpression_1;
      }
      _xtrycatchfinallyexpression = _switchResult;
    } finally {
      task.stop();
    }
    _xblockexpression = _xtrycatchfinallyexpression;
  }
  return _xblockexpression;
}