package de.vogella.jdt.newelements.handler;

import org.eclipse.core.commands.AbstractHandler;
import org.eclipse.core.commands.ExecutionEvent;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;

public class AddPackage extends AbstractHandler {

    @Override
    public Object execute(ExecutionEvent event) throws ExecutionException {
        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        IWorkspaceRoot root = workspace.getRoot();
        // Get all projects in the workspace
        IProject[] projects = root.getProjects();
        // Loop over all projects
        for (IProject project : projects) {
            try {
                // only work on open projects with the Java nature
                if (project.isOpen()
                        & project.isNatureEnabled(JavaCore.NATURE_ID)) {
                    createPackage(project);
                }
            } catch (CoreException e) {
                e.printStackTrace();
        }
        return null;
    }

    private void createPackage(IProject project) throws JavaModelException {
        IJavaProject javaProject = JavaCore.create(project);
        IFolder folder = project.getFolder("src");
        // folder.create(true, true, null);
        IPackageFragmentRoot srcFolder = javaProject
                .getPackageFragmentRoot(folder);
        IPackageFragment fragment = srcFolder.createPackageFragment(
                project.getName(), true, null);
    }
}

package de.vogella.jdt.addclasspath.handlers;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IWorkspace;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.e4.core.di.annotations.Execute;

public class GlobalModifyClasspathHandler {

    private static final String JDT_NATURE = "org.eclipse.jdt.core.javanature";
    
    @Execute
    public void execute() {
        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        IWorkspaceRoot root = workspace.getRoot();
        // Get all projects in the workspace
        IProject[] projects = root.getProjects();
        // Loop over all projects
        for (IProject project : projects) {
            try {
                // only work on open projects with the Java nature
                if (project.isOpen() && project.isNatureEnabled(JDT_NATURE)) {
                    changeClassPath(project);
                }
            } catch (CoreException e) {
                e.printStackTrace(); 
            }
        }
    }
    
    private void changeClasspath(IProject project) throws JavaModelException {
        IJavaProject javaProject = JavaCore.create(project);
        IClasspathEntry[] entries = javaProject.getRawClasspath();
        IClasspathEntry[] newEntries = new IClasspathEntry[entries.length + 1];

        System.arraycopy(entries, 0, newEntries, 0, entries.length);

        // add a new entry using the path to the container
        Path junitPath = new Path(
                "org.eclipse.jdt.junit.JUNIT_CONTAINER/4");
        IClasspathEntry junitEntry = JavaCore
                .newContainerEntry(junitPath);
        newEntries[entries.length] = JavaCore
                .newContainerEntry(junitEntry.getPath());
        javaProject.setRawClasspath(newEntries, null);
    }
    
    
}

package de.vogella.jdt.addclasspath.handlers;

import jakarta.inject.Named;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;
import org.eclipse.e4.core.di.annotations.CanExecute;
import org.eclipse.e4.core.di.annotations.Execute;
import org.eclipse.e4.ui.services.IServiceConstants;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaElement;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.osgi.framework.Bundle;
import org.osgi.framework.FrameworkUtil;

public class ModifyClasspathHandler {

    @Execute
    public void execute(@Named(IServiceConstants.ACTIVE_SELECTION) IStructuredSelection selection)
            throws JavaModelException {
        Object firstElement = selection.getFirstElement();
        if (firstElement instanceof IJavaElement) {

            // Get the selected IJavaProject
            final IJavaElement javaElement = (IJavaElement) firstElement;
            Job job = Job.create("Setting the classpath", monitor -> {
                IJavaProject javaProject = javaElement.getJavaProject();

                // Test the best and get the IClasspathEntry for
                // mockito-core
                Path path = new Path(
                        "/home/simon/.m2/repository/org/mockito/mockito-core/1.8.4/mockito-core-1.8.4.jar");
                IClasspathEntry libraryEntry = JavaCore.newLibraryEntry(path, null, null);

                try {
                    // add the classpath to mockito-core for the java
                    // project
                    javaProject.setRawClasspath(new IClasspathEntry[] { libraryEntry }, monitor);
                } catch (JavaModelException e) {
                    Bundle bundle = FrameworkUtil.getBundle(getClass());
                    return new Status(Status.ERROR, bundle.getSymbolicName(),
                            "Could not set classpath to Java project: " + javaProject.getElementName(), e);
                }
                return Status.OK_STATUS;
            });

            job.schedule();
        }
    }

    @CanExecute
    public boolean canExecute(@Named(IServiceConstants.ACTIVE_SELECTION) IStructuredSelection selection) {
        return selection.getFirstElement() instanceof IJavaElement;
    }

}

String source = String.join("\n",
        "public class HelloWorld {",
        "    public static void main(String[] args) {",
                  // Insert the following statement.
                  // System.out.println("Hello, World");
        "    }",
        "}");

ASTParser parser = ASTParser.newParser(AST.JLS8);
parser.setSource(source.toCharArray());
parser.setKind(ASTParser.K_COMPILATION_UNIT);

CompilationUnit unit = (CompilationUnit) parser.createAST(new NullProgressMonitor());

unit.accept(new ASTVisitor() {

    @SuppressWarnings("unchecked")
    public boolean visit(MethodDeclaration node) {
        AST ast = node.getAST();

        MethodInvocation methodInvocation = ast.newMethodInvocation();

        // System.out.println("Hello, World")
        QualifiedName qName =
                   ast.newQualifiedName(
                            ast.newSimpleName("System"),
                            ast.newSimpleName("out"));
        methodInvocation.setExpression(qName);
        methodInvocation.setName(ast.newSimpleName("println"));

        StringLiteral literal = ast.newStringLiteral();
        literal.setLiteralValue("Hello, World");
        methodInvocation.arguments().add(literal);

        // Append the statement
        node.getBody().statements().add(ast.newExpressionStatement(methodInvocation));

        return super.visit(node);
    }
});

        IWorkspace workspace = ResourcesPlugin.getWorkspace();
        IPath path = Path.fromOSString("/some/path");
        IFile file = workspace.getRoot().getFile(path);
        CompilationUnit compilationUnit =  (CompilationUnit) JavaCore.create(file);
        ICompilationUnit element =  JavaCore.createCompilationUnitFrom(file);
        ASTParser parser = ASTParser.newParser(AST.JLS8);
        parser.setResolveBindings(true);
        parser.setKind(ASTParser.K_COMPILATION_UNIT);
        parser.setBindingsRecovery(true);
        parser.setSource(element);
        CompilationUnit astRoot = (CompilationUnit) parser.createAST(null);

        ASTParser parser = ASTParser.newParser(AST.JLS8);
        parser.setResolveBindings(true);
        parser.setStatementsRecovery(true);
        parser.setBindingsRecovery(true);
        parser.setKind(ASTParser.K_COMPILATION_UNIT);
        File resource = new File("./tests/resources/Snippet.java");
        java.nio.file.Path sourcePath = Paths.get(resource.toURI());
        String sourceString = new String(Files.readAllBytes(sourcePath));
        char[] source = sourceString.toCharArray();
        parser.setSource(source);
        parser.setUnitName(sourcePath.toAbsolutePath().toString());
        CompilationUnit astRoot = (CompilationUnit) parser.createAST(null);

         Document document = new Document("import java.util.List;\nclass X {}\n");
         ASTParser parser = ASTParser.newParser(AST.JLS8);
         parser.setSource(document.get().toCharArray());
         CompilationUnit cu = (CompilationUnit) parser.createAST(null);
         AST ast = cu.getAST();
         ImportDeclaration id = ast.newImportDeclaration();
         id.setName(ast.newName(new String[] {"java", "util", "Set"}));
         ASTRewrite rewriter = ASTRewrite.create(ast);
         ListRewrite lrw = rewriter.getListRewrite(cu, CompilationUnit.IMPORTS_PROPERTY);
         lrw.insertLast(id, null);
         TextEdit edits = rewriter.rewriteAST(document, null);
         edits.apply(document);
         assert "import java.util.List;\nimport java.util.Set;\nclass X {}\n".equals(document.get());

    protected void saveChanges(ICompilationUnit cu, IProgressMonitor monitor, final ASTRewrite rewriter,
            ImportRewrite importRewrite) throws CoreException, JavaModelException, BadLocationException {
        TextEdit importEdits = importRewrite.rewriteImports(monitor);
        TextEdit edits = rewriter.rewriteAST();
        importEdits.addChild(edits);

        // apply the text edits to the compilation unit
        Document document = new Document(cu.getSource());
        importEdits.apply(document);

        // save the compilation unit
        cu.getBuffer().setContents(document.get());
        cu.save(monitor, true);
    }

protected IMember getIMemberAt(IType type, int lineNumber) throws Exception {
    IMember member = null;
    if (type != null) {
        IJavaElement sourceElement = null;
        String source = null;
        if (type.isBinary()) {
            IClassFile classFile = type.getClassFile();
            source = classFile.getSource();
            sourceElement = classFile;
        } else {
            ICompilationUnit unit = type.getCompilationUnit();
            source = unit.getSource();
            sourceElement = unit;
        }
        // translate line number to offset
        if (source != null) {
            Document document = new Document(source);
            IRegion region = document.getLineInformation(lineNumber);
            if (sourceElement instanceof ICompilationUnit) {
                member = (IMember) ((ICompilationUnit)sourceElement).getElementAt(region.getOffset());
            } else {
                member = (IMember) ((IClassFile)sourceElement).getElementAt(region.getOffset());
            }
        }
    }
    return member;
}

@Override
public CleanUpRequirements getRequirements() {
    boolean changedRegionsRequired = false;
    Map<String, String> compilerOptions = null;
    boolean isUpdateCopyrights = options.isEnabled(CLEANUP_COPYRIGHTS_FLAG);
    return new CleanUpRequirements(isUpdateCopyrights, isUpdateCopyrights, changedRegionsRequired, compilerOptions);
}

@Override
public String[] getStepDescriptions() {
    if (options.isEnabled(CLEANUP_COPYRIGHTS_FLAG)) {
        return new String[] {"Update Copyrights"};//$NON-NLS-1$
    }
    return null;
}

@Override
public void setOptions(CleanUpOptions options) {
    Assert.isLegal(options != null);
    Assert.isTrue(options == null);
    this.options = options;
}

@Override
public RefactoringStatus checkPreConditions(IJavaProject project, ICompilationUnit[] compilationUnits, IProgressMonitor monitor) throws CoreException {
    if (options.isEnabled(CLEANUP_COPYRIGHTS_FLAG)) {
        status = new RefactoringStatus();
    }
    return new RefactoringStatus();
}

@Override
public RefactoringStatus checkPostConditions(IProgressMonitor monitor) throws CoreException {
    try {
        if (status == null || status.isOK()) {
            return new RefactoringStatus();
        } else {
            return status;
        }
    } finally {
        status = null;
    }
}

@Override
public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
    CompilationUnit compilationUnit = context.getAST();
    if (compilationUnit == null) {
        return null;
    }

    return CopyrightsFix.createCleanUp(compilationUnit, options.isEnabled(CLEANUP_COPYRIGHTS_FLAG));
}

package com.vogella.jdt.quickfix2;

import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTVisitor;
import org.eclipse.jdt.core.dom.ArrayAccess;
import org.eclipse.jdt.core.dom.FieldDeclaration;
import org.eclipse.jdt.core.dom.SimpleName;
import org.eclipse.jdt.core.dom.TypeDeclaration;
import org.eclipse.jdt.internal.ui.javaeditor.CompilationUnitEditor;
import org.eclipse.jdt.internal.ui.text.correction.AssistContext;
import org.eclipse.jdt.internal.ui.text.java.AbstractJavaCompletionProposal;
import org.eclipse.jdt.ui.actions.AddGetterSetterAction;
import org.eclipse.jdt.ui.text.java.IInvocationContext;
import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;
import org.eclipse.jdt.ui.text.java.IProblemLocation;
import org.eclipse.jdt.ui.text.java.IQuickAssistProcessor;
import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.viewers.StyledString;
import org.eclipse.swt.graphics.Image;

@SuppressWarnings("restriction")
public class QuickAssistsProcessorGetterSetter implements IQuickAssistProcessor {
    private boolean hasFields = false;

    @Override
    public boolean hasAssists(IInvocationContext context) throws CoreException {
        // currently hasAssists is not called by JDT
        return true;
    }

    @Override
    public IJavaCompletionProposal[] getAssists(IInvocationContext context, IProblemLocation[] locations)
            throws CoreException {
        hasFields = false;
        ASTNode coveringNode = context.getCoveringNode();
        if (coveringNode == null) {
            return null;
        }
        // we should have selected a class name
        if (!(coveringNode instanceof SimpleName)) {
            return null;
        }
        // ensure that simple names parent is a type declaration
        if (!(coveringNode.getParent() instanceof TypeDeclaration)) {
            return null;
        }
        coveringNode.getRoot().accept(new ASTVisitor() {
            @Override
            public boolean visit(FieldDeclaration node) {
                hasFields = true;
                return super.visit(node);
            }
        });

        if (!hasFields) {
            return null;
        }

        List<IJavaCompletionProposal> proposals = new ArrayList<>();

        addGetterAndSetterProposal(context, proposals);

        return proposals.toArray(new IJavaCompletionProposal[proposals.size()]);
    }

    private void addGetterAndSetterProposal(IInvocationContext context, List<IJavaCompletionProposal> proposals) {
        proposals.add(new AbstractJavaCompletionProposal() {
            @Override
            public StyledString getStyledDisplayString() {
                ICompilationUnit compilationUnit = context.getCompilationUnit();
                return new StyledString(
                        "Generate Getter and setter for " + compilationUnit.findPrimaryType().getElementName());
            }

            @Override
            protected int getPatternMatchRule(String pattern, String string) {
                // override the match rule since we do not work with a pattern, but just want to
                // open the "Generate Getters and Setters..." dialog
                return -1;
            };

            @Override
            public void apply(ITextViewer viewer, char trigger, int stateMask, int offset) {
                if (context instanceof AssistContext) {
                    AssistContext assistContext = (AssistContext) context;
                    AddGetterSetterAction addGetterSetterAction = new AddGetterSetterAction(
                            (CompilationUnitEditor) assistContext.getEditor());

                    addGetterSetterAction.run();
                }
            }
        });
    }
}

package com.vogella.jdt.quickfix;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.jdt.core.ICompilationUnit;
import org.eclipse.jdt.ui.text.java.IInvocationContext;
import org.eclipse.jdt.ui.text.java.IJavaCompletionProposal;
import org.eclipse.jdt.ui.text.java.IProblemLocation;
import org.eclipse.jdt.ui.text.java.IQuickFixProcessor;

public class ProblemIdQuickFixProcessor implements IQuickFixProcessor {

    @Override
    public boolean hasCorrections(ICompilationUnit unit, int problemId) {
        
        System.out.println(problemId);
        
        return false;
    }

    @Override
    public IJavaCompletionProposal[] getCorrections(IInvocationContext context, IProblemLocation[] locations)
            throws CoreException {
        
        return null;
    }

}

public class CopyrightsFix implements ICleanUp {

    public static final String CLEANUP_COPYRIGHTS_FLAG = "cleanup.update_copyrights";
    private CleanUpOptions options;
    private RefactoringStatus status;

    public CopyrightsFix() {
    }

    @Override
    public CleanUpRequirements getRequirements() {
        boolean changedRegionsRequired = false;
        Map<String, String> compilerOptions = null;
        boolean isUpdateCopyrights = options.isEnabled(CLEANUP_COPYRIGHTS_FLAG);
        return new CleanUpRequirements(isUpdateCopyrights, isUpdateCopyrights, changedRegionsRequired, compilerOptions);
    }

    @Override
    public String[] getStepDescriptions() {
        if (options.isEnabled(CLEANUP_COPYRIGHTS_FLAG)) {
            return new String[] {"Update Copyrights"};//$NON-NLS-1$
        }
        return null;
    }

    @Override
    public void setOptions(CleanUpOptions options) {
        Assert.isLegal(options != null);
        Assert.isTrue(options == null);
        this.options = options;
    }

    @Override
    public RefactoringStatus checkPreConditions(IJavaProject project, ICompilationUnit[] compilationUnits, IProgressMonitor monitor) throws CoreException {
        if (options.isEnabled(CLEANUP_COPYRIGHTS_FLAG)) {
            status = new RefactoringStatus();
        }
        return new RefactoringStatus();
    }

    @Override
    public RefactoringStatus checkPostConditions(IProgressMonitor monitor) throws CoreException {
        try {
            if (status == null || status.isOK()) {
                return new RefactoringStatus();
            } else {
                return status;
            }
        } finally {
            status = null;
        }
    }

    @Override
    public ICleanUpFix createFix(CleanUpContext context) throws CoreException {
        CompilationUnit compilationUnit = context.getAST();
        if (compilationUnit == null) {
            return null;
        }

        return CopyrightsFix.createCleanUp(compilationUnit, options.isEnabled(CLEANUP_COPYRIGHTS_FLAG));
    }

}

public class CopyrightOnSaveOptionsInitializer implements ICleanUpOptionsInitializer {

    @Override
    public void setDefaultOptions(CleanUpOptions options) {
        options.setOption(CopyrightsFix.CLEANUP_COPYRIGHTS_FLAG, CleanUpOptions.TRUE);
    }

}

public class CopyrightTabPage implements ICleanUpConfigurationUI {

    private static final int CURRENT_YEAR = Calendar.getInstance().get(Calendar.YEAR);

    private CleanUpOptions options;

    public CopyrightTabPage() {
        super();
    }

    @Override
    public void setOptions(CleanUpOptions options) {
        this.options = options;
    }

    @Override
    public Composite createContents(Composite parent) {
        Composite result = new Composite(parent, SWT.NONE);
        result.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));
        GridLayout layout = new GridLayout(1, false);
        layout.marginHeight = 0;
        layout.marginWidth = 0;
        result.setLayout(layout);

        Group group= new Group(result, SWT.NONE);
        group.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false));
        group.setLayout(new GridLayout(1, false));
        group.setText("Copyright Update");

        final Button updateCheckbox= new Button(group, SWT.CHECK);
        updateCheckbox.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER, false, false));
        updateCheckbox.setText("Update the Copyrights");
        updateCheckbox.setSelection(options.isEnabled(CopyrightsFix.CLEANUP_COPYRIGHTS_FLAG));
        updateCheckbox.addSelectionListener(SelectionListener.widgetSelectedAdapter(e -> {
            options.setOption(CopyrightsFix.CLEANUP_COPYRIGHTS_FLAG,
                    updateCheckbox.getSelection() ? CleanUpOptions.TRUE : CleanUpOptions.FALSE);
        }));

        return result;
    }

    @Override
    public int getCleanUpCount() {
        return 1;
    }

    @Override
    public int getSelectedCleanUpCount() {
        return options.isEnabled(CopyrightsFix.CLEANUP_COPYRIGHTS_FLAG) ? 1 : 0;
    }

    @Override
    public String getPreview() {
        StringBuffer buf = new StringBuffer();

        buf.append("/*******************************************************************************\n"); //$NON-NLS-1$
        if (options.isEnabled(CopyrightsFix.CLEANUP_COPYRIGHTS_FLAG)) {
            buf.append(" * Copyright (c) 2005, ").append(CURRENT_YEAR).append(" IBM Corporation and others.\n"); //$NON-NLS-1$ //$NON-NLS-2$
        } else {
            buf.append(" * Copyright (c) 2005 IBM Corporation and others.\n"); //$NON-NLS-1$
        }
        buf.append(" * All rights reserved. This  program and the accompanying materials\n"); //$NON-NLS-1$
        buf.append(" * are made available under the terms of the Eclipse Public License v1.0\n"); //$NON-NLS-1$
        buf.append(" * which accompanies this distribution, and is available at\n"); //$NON-NLS-1$
        buf.append(" * http://www.eclipse.org/legal/epl-v10.html\n"); //$NON-NLS-1$
        buf.append(" *\n"); //$NON-NLS-1$
        buf.append(" * Contributors:\n"); //$NON-NLS-1$
        buf.append(" *     IBM Corporation - initial API and implementation\n"); //$NON-NLS-1$
        buf.append(" *******************************************************************************/\n"); //$NON-NLS-1$

        return buf.toString();
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<templates>
    <template name="localvariable" description="Local Variable"
        id="org.eclipse.jdt.ui.templates.localvariable" context="java-statements"
        enabled="true" autoinsert="false">
        ${variabletype} ${myvar:newName(var)}= new ${variabletype}(${cursor});
    </template>
    
    <template name="string" description="String (empty)"
        id="org.eclipse.jdt.ui.templates.emptystring" context="java-statements"
        enabled="true" autoinsert="false">
        String ${myvar:newName(var)}= "";
    </template>

    <template name="arrayexample" description="Creates an Array with some example content"
        id="org.eclipse.jdt.ui.templates.arrayexample" context="java-statements"
        enabled="true" autoinsert="false">
        String[] ${myvar:newName(var)} =
        new String[]{"Windows 7", "MacOS", "Debian", "Ubuntu", "Redhat",
        "Android", "iPhone", "Suse", "Windows XP", "Windows Mobile", "OS/2", "WebOS"};
    </template>

</templates>

   <extension
         point="org.eclipse.ui.editors.templates">
      <include
            file="additional-templates.xml">
      </include>
   </extension>