/* -*- mode: java; c-basic-offset: 2; indent-tabs-mode: nil -*- */

/*

Part of the Processing project - http://processing.org

Copyright (c) 2012-15 The Processing Foundation

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License version 2

as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software Foundation, Inc.

51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

*/

package processing.mode.java.pdex;

import java.awt.BorderLayout;

import java.awt.Dimension;

import java.awt.EventQueue;

import java.awt.Rectangle;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.io.File;

import java.io.FileFilter;

import java.io.IOException;

import java.lang.reflect.Constructor;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Stack;

import java.util.TreeMap;

import java.util.TreeSet;

import java.util.regex.Pattern;

import javax.swing.BorderFactory;

import javax.swing.Box;

import javax.swing.BoxLayout;

import javax.swing.DefaultListModel;

import javax.swing.JButton;

import javax.swing.JComponent;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextField;

import javax.swing.JTree;

import javax.swing.ListSelectionModel;

import javax.swing.SwingWorker;

import javax.swing.event.TreeSelectionEvent;

import javax.swing.event.TreeSelectionListener;

import javax.swing.text.BadLocationException;

import javax.swing.text.Element;

import javax.swing.text.PlainDocument;

import javax.swing.tree.DefaultMutableTreeNode;

import javax.swing.tree.DefaultTreeModel;

import javax.swing.tree.MutableTreeNode;

import org.eclipse.jdt.core.JavaCore;

import org.eclipse.jdt.core.dom.AST;

import org.eclipse.jdt.core.dom.ASTNode;

import org.eclipse.jdt.core.dom.ASTParser;

import org.eclipse.jdt.core.dom.ArrayAccess;

import org.eclipse.jdt.core.dom.ArrayType;

import org.eclipse.jdt.core.dom.Block;

import org.eclipse.jdt.core.dom.Comment;

import org.eclipse.jdt.core.dom.CompilationUnit;

import org.eclipse.jdt.core.dom.Expression;

import org.eclipse.jdt.core.dom.ExpressionStatement;

import org.eclipse.jdt.core.dom.FieldAccess;

import org.eclipse.jdt.core.dom.FieldDeclaration;

import org.eclipse.jdt.core.dom.MethodDeclaration;

import org.eclipse.jdt.core.dom.MethodInvocation;

import org.eclipse.jdt.core.dom.Name;

import org.eclipse.jdt.core.dom.ParameterizedType;

import org.eclipse.jdt.core.dom.PrimitiveType;

import org.eclipse.jdt.core.dom.QualifiedName;

import org.eclipse.jdt.core.dom.SimpleName;

import org.eclipse.jdt.core.dom.SimpleType;

import org.eclipse.jdt.core.dom.SingleVariableDeclaration;

import org.eclipse.jdt.core.dom.StructuralPropertyDescriptor;

import org.eclipse.jdt.core.dom.Type;

import org.eclipse.jdt.core.dom.TypeDeclaration;

import org.eclipse.jdt.core.dom.VariableDeclarationExpression;

import org.eclipse.jdt.core.dom.VariableDeclarationFragment;

import org.eclipse.jdt.core.dom.VariableDeclarationStatement;

import org.jsoup.Jsoup;

import org.jsoup.nodes.Document;

import org.jsoup.select.Elements;

import processing.app.Library;

import processing.app.Messages;

import processing.app.SketchCode;

import processing.app.Util;

import processing.app.syntax.JEditTextArea;

import processing.app.ui.EditorStatus;

import processing.app.ui.Toolkit;

import processing.mode.java.JavaEditor;

import processing.mode.java.preproc.PdePreprocessor;

import com.google.classpath.ClassPath;

import com.google.classpath.ClassPathFactory;

import com.google.classpath.RegExpResourceFilter;

@SuppressWarnings({ "unchecked" })

public class ASTGenerator {

protected final ErrorCheckerService errorCheckerService;

protected JavaEditor editor;

public DefaultMutableTreeNode codeTree = new DefaultMutableTreeNode();

protected JFrame frmASTView;

/** Swing component wrapper for AST, used for internal testing */

protected JTree jtree;

/** JTree used for testing refactoring operations */

protected JTree refactorTree;

protected CompilationUnit compilationUnit;

protected JFrame frmRename;

protected JButton btnRename;

protected JButton btnListOccurrence;

protected JTextField txtRenameField;

protected JFrame frmOccurenceList;

protected JLabel lblRefactorOldName;

public ASTGenerator(ErrorCheckerService ecs) {

this.errorCheckerService = ecs;

this.editor = ecs.getEditor();

setupGUI();

//addCompletionPopupListner();

addListeners();

//loadJavaDoc();

}

protected void setupGUI() {

frmASTView = new JFrame();

jtree = new JTree();

frmASTView.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);

frmASTView.setBounds(new Rectangle(680, 100, 460, 620));

frmASTView.setTitle("AST View - " + editor.getSketch().getName());

JScrollPane sp = new JScrollPane();

sp.setViewportView(jtree);

frmASTView.add(sp);

btnRename = new JButton("Rename");

btnListOccurrence = new JButton("Show Usage");

frmRename = new JFrame();

frmRename.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);

frmRename.setSize(250, 130);

frmRename.setLayout(new BoxLayout(frmRename.getContentPane(), BoxLayout.Y_AXIS));

Toolkit.setIcon(frmRename);

JPanel panelTop = new JPanel(), panelBottom = new JPanel();

panelTop.setLayout(new BoxLayout(panelTop, BoxLayout.Y_AXIS));

panelTop.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));

panelBottom.setLayout(new BoxLayout(panelBottom, BoxLayout.X_AXIS));

panelBottom.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));

panelBottom.add(Box.createHorizontalGlue());

panelBottom.add(btnListOccurrence);

panelBottom.add(Box.createRigidArea(new Dimension(15, 0)));

panelBottom.add(btnRename);

frmRename.setTitle("Enter new name:");

txtRenameField = new JTextField();

txtRenameField.setPreferredSize(new Dimension(150, 60));

panelTop.add(txtRenameField);

//renameWindow.setVisible(true);

lblRefactorOldName = new JLabel();

lblRefactorOldName.setText("Old Name: ");

panelTop.add(Box.createRigidArea(new Dimension(0, 10)));

panelTop.add(lblRefactorOldName);

frmRename.add(panelTop);

frmRename.add(panelBottom);

frmRename.setMinimumSize(frmRename.getSize());

frmRename.setLocation(editor.getX()

+ (editor.getWidth() - frmRename.getWidth()) / 2,

editor.getY()

+ (editor.getHeight() - frmRename.getHeight())

/ 2);

frmOccurenceList = new JFrame();

frmOccurenceList.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);

frmOccurenceList.setSize(300, 400);

Toolkit.setIcon(frmOccurenceList);

JScrollPane sp2 = new JScrollPane();

refactorTree = new JTree();

sp2.setViewportView(refactorTree);

frmOccurenceList.add(sp2);

}

public static final boolean SHOW_AST = false;

protected DefaultMutableTreeNode buildAST(String source, CompilationUnit cu) {

if (cu == null) {

ASTParser parser = ASTParser.newParser(AST.JLS8);

parser.setSource(source.toCharArray());

parser.setKind(ASTParser.K_COMPILATION_UNIT);

Map<String, String> options = JavaCore.getOptions();

JavaCore.setComplianceOptions(JavaCore.VERSION_1_7, options);

parser.setCompilerOptions(options);

compilationUnit = (CompilationUnit) parser.createAST(null);

} else {

compilationUnit = cu;

//log("Other cu");

}

// OutlineVisitor visitor = new OutlineVisitor();

// compilationUnit.accept(visitor);

getCodeComments();

codeTree = new DefaultMutableTreeNode(new ASTNodeWrapper((ASTNode) compilationUnit

.types().get(0)));

//log("Total CU " + compilationUnit.types().size());

if(compilationUnit.types() == null || compilationUnit.types().isEmpty()){

Messages.loge("No CU found!");

}

visitRecur((ASTNode) compilationUnit.types().get(0), codeTree);

SwingWorker<Object, Object> worker = new SwingWorker<Object, Object>() {

@Override

protected Object doInBackground() throws Exception {

return null;

}

@Override

protected void done() {

if (codeTree != null) {

if(SHOW_AST){

if (jtree.hasFocus() || frmASTView.hasFocus())

return;

jtree.setModel(new DefaultTreeModel(codeTree));

((DefaultTreeModel) jtree.getModel()).reload();

jtree.validate();

if (!frmASTView.isVisible()) {

frmASTView.setVisible(true);

}

}

// if (!frameAutoComp.isVisible()) {

//

// frameAutoComp.setVisible(true);

//

// }

// if (!frmJavaDoc.isVisible()) {

// long t = System.currentTimeMillis();

// loadJavaDoc();

// log("Time taken: "

// + (System.currentTimeMillis() - t));

// frmJavaDoc.setBounds(new Rectangle(errorCheckerService.getEditor()

// .getX() + errorCheckerService.getEditor().getWidth(),

// errorCheckerService.getEditor()

// .getY(), 450, 600));

// frmJavaDoc.setVisible(true);

// }

}

}

};

worker.execute();

// Base.loge("++>" + System.getProperty("java.class.path"));

// log(System.getProperty("java.class.path"));

// log("-------------------------------");

return codeTree;

}

protected final ClassPathFactory factory = new ClassPathFactory();

/**

* Used for searching for package declaration of a class

*/

protected ClassPath classPath;

protected TreeMap<String, String> jdocMap;

protected void loadJavaDoc() {

jdocMap = new TreeMap<>();

// presently loading only p5 reference for PApplet

new Thread(new Runnable() {

@Override

public void run() {

try {

loadJavaDoc(jdocMap, editor.getMode().getReferenceFolder());

} catch (Exception e) {

e.printStackTrace();

}

}

}).start();

}

static void loadJavaDoc(TreeMap<String, String> jdocMap,

File referenceFolder) throws IOException {

Document doc;

FileFilter fileFilter = new FileFilter() {

@Override

public boolean accept(File file) {

if(!file.getName().endsWith("_.html"))

return false;

int k = 0;

for (int i = 0; i < file.getName().length(); i++) {

if(file.getName().charAt(i)== '_')

k++;

if(k > 1)

return false;

}

return true;

}

};

for (File docFile : referenceFolder.listFiles(fileFilter)) {

doc = Jsoup.parse(docFile, null);

Elements elm = doc.getElementsByClass("ref-item");

String msg = "";

String methodName = docFile.getName().substring(0, docFile.getName().indexOf('_'));

//System.out.println(methodName);

for (org.jsoup.nodes.Element ele : elm) {

msg = "<html><body> <strong><div style=\"width: 300px; text-justification: justify;\"></strong><table cellpadding=\"0\" cellspacing=\"0\" border=\"0\" class=\"ref-item\">"

+ ele.html() + "</table></div></html></body></html>";

//mat.replaceAll("");

msg = msg.replaceAll("img src=\"", "img src=\""

+ referenceFolder.toURI().toURL().toString() + "/");

//System.out.println(ele.text());

}

jdocMap.put(methodName, msg);

}

//System.out.println("JDoc loaded " + jdocMap.size());

}

public static CompletionCandidate[] checkForTypes(ASTNode node) {

List<VariableDeclarationFragment> vdfs = null;

switch (node.getNodeType()) {

case ASTNode.TYPE_DECLARATION:

return new CompletionCandidate[] { new CompletionCandidate((TypeDeclaration) node) };

case ASTNode.METHOD_DECLARATION:

MethodDeclaration md = (MethodDeclaration) node;

log(getNodeAsString(md));

List<ASTNode> params = (List<ASTNode>) md

.getStructuralProperty(MethodDeclaration.PARAMETERS_PROPERTY);

CompletionCandidate[] cand = new CompletionCandidate[params.size() + 1];

cand[0] = new CompletionCandidate(md);

for (int i = 0; i < params.size(); i++) {

// cand[i + 1] = new CompletionCandidate(params.get(i).toString(), "", "",

// CompletionCandidate.LOCAL_VAR);

cand[i + 1] = new CompletionCandidate((SingleVariableDeclaration)params.get(i));

}

return cand;

case ASTNode.SINGLE_VARIABLE_DECLARATION:

return new CompletionCandidate[] { new CompletionCandidate((SingleVariableDeclaration)node) };

case ASTNode.FIELD_DECLARATION:

vdfs = ((FieldDeclaration) node).fragments();

break;

case ASTNode.VARIABLE_DECLARATION_STATEMENT:

vdfs = ((VariableDeclarationStatement) node).fragments();

break;

case ASTNode.VARIABLE_DECLARATION_EXPRESSION:

vdfs = ((VariableDeclarationExpression) node).fragments();

break;

default:

break;

}

if (vdfs != null) {

CompletionCandidate ret[] = new CompletionCandidate[vdfs.size()];

int i = 0;

for (VariableDeclarationFragment vdf : vdfs) {

// ret[i++] = new CompletionCandidate(getNodeAsString2(vdf), "", "",

// CompletionCandidate.LOCAL_VAR);

ret[i++] = new CompletionCandidate(vdf);

}

return ret;

}

return null;

}

/**

* Find the parent of the expression in a().b, this would give me the return

* type of a(), so that we can find all children of a() begininng with b

*

* @param nearestNode

* @param expression

* @return

*/

public static ASTNode resolveExpression(ASTNode nearestNode,

ASTNode expression, boolean noCompare) {

log("Resolving " + getNodeAsString(expression) + " noComp "

+ noCompare);

if (expression instanceof SimpleName) {

return findDeclaration2(((SimpleName) expression), nearestNode);

} else if (expression instanceof MethodInvocation) {

log("3. Method Invo "

+ ((MethodInvocation) expression).getName());

return findDeclaration2(((MethodInvocation) expression).getName(),

nearestNode);

} else if (expression instanceof FieldAccess) {

log("2. Field access "

+ getNodeAsString(((FieldAccess) expression).getExpression()) + "|||"

+ getNodeAsString(((FieldAccess) expression).getName()));

if (noCompare) {

/*

* ASTNode ret = findDeclaration2(((FieldAccess) expression).getName(),

* nearestNode); log("Found as ->"+getNodeAsString(ret));

* return ret;

*/

return findDeclaration2(((FieldAccess) expression).getName(),

nearestNode);

} else {

/*

* Note how for the next recursion, noCompare is reversed. Let's say

* I've typed getABC().quark.nin where nin is incomplete(ninja being the

* field), when execution first enters here, it calls resolveExpr again

* for "getABC().quark" where we know that quark field must be complete,

* so we toggle noCompare. And kaboom.

*/

return resolveExpression(nearestNode,

((FieldAccess) expression).getExpression(),

true);

}

//return findDeclaration2(((FieldAccess) expression).getExpression(), nearestNode);

} else if (expression instanceof QualifiedName) {

log("1. Resolving "

+ ((QualifiedName) expression).getQualifier() + " ||| "

+ ((QualifiedName) expression).getName());

if (noCompare) { // no compare, as in "abc.hello." need to resolve hello here

return findDeclaration2(((QualifiedName) expression).getName(),

nearestNode);

} else {

//User typed "abc.hello.by" (bye being complete), so need to resolve "abc.hello." only

return findDeclaration2(((QualifiedName) expression).getQualifier(),

nearestNode);

}

}

return null;

}

/**

* Finds the type of the expression in foo.bar().a().b, this would give me the

* type of b if it exists in return type of a(). If noCompare is true,

* it'll return type of a()

* @param nearestNode

* @param astNode

* @return

*/

public ClassMember resolveExpression3rdParty(ASTNode nearestNode,

ASTNode astNode, boolean noCompare) {

log("Resolve 3rdParty expr-- " + getNodeAsString(astNode)

+ " nearest node " + getNodeAsString(nearestNode));

if(astNode == null) return null;

ClassMember scopeParent;

SimpleType stp;

if(astNode instanceof SimpleName){

ASTNode decl = findDeclaration2(((SimpleName)astNode),nearestNode);

if(decl != null){

// see if locally defined

log(getNodeAsString(astNode)+" found decl -> " + getNodeAsString(decl));

{

if (decl.getNodeType() == ASTNode.TYPE_DECLARATION) {

TypeDeclaration td = (TypeDeclaration) decl;

return new ClassMember(td);

}

}

{ // Handle "array." x "array[1]."

Type type = extracTypeInfo2(decl);

if (type != null && type.isArrayType() &&

astNode.getParent().getNodeType() != ASTNode.ARRAY_ACCESS) {

// No array access, we want members of the array itself

Type elementType = ((ArrayType) type).getElementType();

// Get name of the element class

String name = "";

if (elementType.isSimpleType()) {

Class<?> c = findClassIfExists(elementType.toString());

if (c != null) name = c.getName();

} else if (elementType.isPrimitiveType()) {

name = ((PrimitiveType) elementType).getPrimitiveTypeCode().toString();

}

// Convert element class to array class

Class<?> arrayClass = getArrayClass(name);

return arrayClass == null ? null : new ClassMember(arrayClass);

}

}

return new ClassMember(extracTypeInfo(decl));

}

else {

// or in a predefined class?

Class<?> tehClass = findClassIfExists(astNode.toString());

if (tehClass != null) {

return new ClassMember(tehClass);

}

}

astNode = astNode.getParent();

}

switch (astNode.getNodeType()) {

//TODO: Notice the redundancy in the 3 cases, you can simplify things even more.

case ASTNode.FIELD_ACCESS:

FieldAccess fa = (FieldAccess) astNode;

if (fa.getExpression() == null) {

// TODO: Check for existence of 'new' keyword. Could be a ClassInstanceCreation

// Local code or belongs to super class

log("FA,Not implemented.");

return null;

} else {

if (fa.getExpression() instanceof SimpleName) {

stp = extracTypeInfo(findDeclaration2((SimpleName) fa.getExpression(),

nearestNode));

if(stp == null){

/*The type wasn't found in local code, so it might be something like

* log(), or maybe belonging to super class, etc.

*/

Class<?> tehClass = findClassIfExists(fa.getExpression().toString());

if (tehClass != null) {

// Method Expression is a simple name and wasn't located locally, but found in a class

// so look for method in this class.

return definedIn3rdPartyClass(new ClassMember(tehClass), fa

.getName().toString());

}

log("FA resolve 3rd par, Can't resolve " + fa.getExpression());

return null;

}

log("FA, SN Type " + getNodeAsString(stp));

scopeParent = definedIn3rdPartyClass(stp.getName().toString(), "THIS");

} else {

scopeParent = resolveExpression3rdParty(nearestNode,

fa.getExpression(), noCompare);

}

log("FA, ScopeParent " + scopeParent);

return definedIn3rdPartyClass(scopeParent, fa.getName().toString());

}

case ASTNode.METHOD_INVOCATION:

MethodInvocation mi = (MethodInvocation) astNode;

ASTNode temp = findDeclaration2(mi.getName(), nearestNode);

if(temp instanceof MethodDeclaration){

// method is locally defined

log(mi.getName() + " was found locally," + getNodeAsString(extracTypeInfo(temp)));

{ // Handle "array." x "array[1]."

Type type = extracTypeInfo2(temp);

if (type != null && type.isArrayType() &&

astNode.getParent().getNodeType() != ASTNode.ARRAY_ACCESS) {

// No array access, we want members of the array itself

Type elementType = ((ArrayType) type).getElementType();

// Get name of the element class

String name = "";

if (elementType.isSimpleType()) {

Class<?> c = findClassIfExists(elementType.toString());

if (c != null) name = c.getName();

} else if (elementType.isPrimitiveType()) {

name = ((PrimitiveType) elementType).getPrimitiveTypeCode().toString();

}

// Convert element class to array class

Class<?> arrayClass = getArrayClass(name);

return arrayClass == null ? null : new ClassMember(arrayClass);

}

}

return new ClassMember(extracTypeInfo(temp));

}

if (mi.getExpression() == null) {

// if()

//Local code or belongs to super class

log("MI,Not implemented.");

return null;

} else {

if (mi.getExpression() instanceof SimpleName) {

ASTNode decl = findDeclaration2((SimpleName) mi.getExpression(),

nearestNode);

if (decl != null) {

if (decl.getNodeType() == ASTNode.TYPE_DECLARATION) {

TypeDeclaration td = (TypeDeclaration) decl;

return new ClassMember(td);

}

stp = extracTypeInfo(decl);

if(stp == null){

/*The type wasn't found in local code, so it might be something like

* System.console()., or maybe belonging to super class, etc.

*/

Class<?> tehClass = findClassIfExists(mi.getExpression().toString());

if (tehClass != null) {

// Method Expression is a simple name and wasn't located locally, but found in a class

// so look for method in this class.

return definedIn3rdPartyClass(new ClassMember(tehClass), mi

.getName().toString());

}

log("MI resolve 3rd par, Can't resolve " + mi.getExpression());

return null;

}

log("MI, SN Type " + getNodeAsString(stp));

ASTNode typeDec = findDeclaration2(stp.getName(),nearestNode);

if(typeDec == null){

log(stp.getName() + " couldn't be found locally..");

Class<?> tehClass = findClassIfExists(stp.getName().toString());

if (tehClass != null) {

// Method Expression is a simple name and wasn't located locally, but found in a class

// so look for method in this class.

return definedIn3rdPartyClass(new ClassMember(tehClass), mi

.getName().toString());

}

//return new ClassMember(findClassIfExists(stp.getName().toString()));

}

//scopeParent = definedIn3rdPartyClass(stp.getName().toString(), "THIS");

return definedIn3rdPartyClass(new ClassMember(typeDec), mi

.getName().toString());

}

} else {

log("MI EXP.."+getNodeAsString(mi.getExpression()));

// return null;

scopeParent = resolveExpression3rdParty(nearestNode,

mi.getExpression(), noCompare);

log("MI, ScopeParent " + scopeParent);

return definedIn3rdPartyClass(scopeParent, mi.getName().toString());

}

}

case ASTNode.QUALIFIED_NAME:

QualifiedName qn = (QualifiedName) astNode;

ASTNode temp2 = findDeclaration2(qn.getName(), nearestNode);

if(temp2 instanceof FieldDeclaration){

// field is locally defined

log(qn.getName() + " was found locally," + getNodeAsString(extracTypeInfo(temp2)));

return new ClassMember(extracTypeInfo(temp2));

}

if (qn.getQualifier() == null) {

log("QN,Not implemented.");

return null;

} else {

if (qn.getQualifier() instanceof SimpleName) {

stp = extracTypeInfo(findDeclaration2(qn.getQualifier(), nearestNode));

if(stp == null){

/*The type wasn't found in local code, so it might be something like

* log(), or maybe belonging to super class, etc.

*/

Class<?> tehClass = findClassIfExists(qn.getQualifier().toString());

if (tehClass != null) {

// note how similar thing is called on line 690. Check check.

return definedIn3rdPartyClass(new ClassMember(tehClass), qn

.getName().toString());

}

log("QN resolve 3rd par, Can't resolve " + qn.getQualifier());

return null;

}

log("QN, SN Local Type " + getNodeAsString(stp));

//scopeParent = definedIn3rdPartyClass(stp.getName().toString(), "THIS");

ASTNode typeDec = findDeclaration2(stp.getName(),nearestNode);

if(typeDec == null){

log(stp.getName() + " couldn't be found locally..");

Class<?> tehClass = findClassIfExists(stp.getName().toString());

if (tehClass != null) {

// note how similar thing is called on line 690. Check check.

return definedIn3rdPartyClass(new ClassMember(tehClass), qn

.getName().toString());

}

log("QN resolve 3rd par, Can't resolve " + qn.getQualifier());

return null;

}

return definedIn3rdPartyClass(new ClassMember(typeDec), qn

.getName().toString());

} else {

scopeParent = resolveExpression3rdParty(nearestNode,

qn.getQualifier(), noCompare);

log("QN, ScopeParent " + scopeParent);

return definedIn3rdPartyClass(scopeParent, qn.getName().toString());

}

}

case ASTNode.ARRAY_ACCESS:

ArrayAccess arac = (ArrayAccess)astNode;

return resolveExpression3rdParty(nearestNode, arac.getArray(), noCompare);

default:

log("Unaccounted type " + getNodeAsString(astNode));

break;

}

return null;

}

public Class<?> getArrayClass(String elementClass) {

String name;

if (elementClass.startsWith("[")) {

// just add a leading "["

name = "[" + elementClass;

} else if (elementClass.equals("boolean")) {

name = "[Z";

} else if (elementClass.equals("byte")) {

name = "[B";

} else if (elementClass.equals("char")) {

name = "[C";

} else if (elementClass.equals("double")) {

name = "[D";

} else if (elementClass.equals("float")) {

name = "[F";

} else if (elementClass.equals("int")) {

name = "[I";

} else if (elementClass.equals("long")) {

name = "[J";

} else if (elementClass.equals("short")) {

name = "[S";

} else {

// must be an object non-array class

name = "[L" + elementClass + ";";

}

return loadClass(name);

}

/**

* For a().abc.a123 this would return a123

*

* @param expression

* @return

*/

public static ASTNode getChildExpression(ASTNode expression) {

// ASTNode anode = null;

if (expression instanceof SimpleName) {

return expression;

} else if (expression instanceof FieldAccess) {

return ((FieldAccess) expression).getName();

} else if (expression instanceof QualifiedName) {

return ((QualifiedName) expression).getName();

}else if (expression instanceof MethodInvocation) {

return ((MethodInvocation) expression).getName();

}else if(expression instanceof ArrayAccess){

return ((ArrayAccess)expression).getArray();

}

log(" getChildExpression returning NULL for "

+ getNodeAsString(expression));

return null;

}

public static ASTNode getParentExpression(ASTNode expression) {

// ASTNode anode = null;

if (expression instanceof SimpleName) {

return expression;

} else if (expression instanceof FieldAccess) {

return ((FieldAccess) expression).getExpression();

} else if (expression instanceof QualifiedName) {

return ((QualifiedName) expression).getQualifier();

} else if (expression instanceof MethodInvocation) {

return ((MethodInvocation) expression).getExpression();

} else if (expression instanceof ArrayAccess) {

return ((ArrayAccess) expression).getArray();

}

log("getParentExpression returning NULL for "

+ getNodeAsString(expression));

return null;

}

protected static List<CompletionCandidate> trimCandidates(String newWord, List<CompletionCandidate> candidates) {

ArrayList<CompletionCandidate> newCandidate = new ArrayList<>();

newWord = newWord.toLowerCase();

for (CompletionCandidate comp : candidates) {

if(comp.getNoHtmlLabel().toLowerCase().startsWith(newWord)){

newCandidate.add(comp);

}

}

return newCandidate;

}

protected List<CompletionCandidate> candidates;

protected String lastPredictedPhrase = " ";

/**

* The main function that calculates possible code completion candidates

*

* @param pdePhrase

* @param line

* @param lineStartNonWSOffset

*/

public List<CompletionCandidate> preparePredictions(final String pdePhrase,

final int line) {

ErrorCheckerService errorCheckerService = editor.getErrorChecker();

ASTNode astRootNode = (ASTNode) errorCheckerService.getLatestCU().types().get(0);

// If the parsed code contains pde enhancements, take 'em out.

String phrase = ASTNodeWrapper.getJavaCode(pdePhrase);

//After typing 'arg.' all members of arg type are to be listed. This one is a flag for it

boolean noCompare = phrase.endsWith(".");

if (noCompare) {

phrase = phrase.substring(0, phrase.length() - 1);

}

boolean incremental = !noCompare &&

phrase.length() > lastPredictedPhrase.length() &&

phrase.startsWith(lastPredictedPhrase);

if (incremental) {

log(pdePhrase + " starts with " + lastPredictedPhrase);

log("Don't recalc");

if (phrase.contains(".")) {

int x = phrase.lastIndexOf('.');

candidates = trimCandidates(phrase.substring(x + 1), candidates);

} else {

candidates = trimCandidates(phrase, candidates);

}

lastPredictedPhrase = phrase;

return candidates;

}

int lineNumber = line;

// Adjust line number for tabbed sketches

int codeIndex = editor.getSketch().getCodeIndex(editor.getCurrentTab());

if (codeIndex > 0) {

for (int i = 0; i < codeIndex; i++) {

SketchCode sc = editor.getSketch().getCode(i);

int len = Util.countLines(sc.getProgram()) + 1;

lineNumber += len;

}

}

// Ensure that we're not inside a comment. TODO: Binary search

/*for (Comment comm : getCodeComments()) {

int commLineNo = PdeToJavaLineNumber(compilationUnit

.getLineNumber(comm.getStartPosition()));

if(commLineNo == lineNumber){

log("Found a comment line " + comm);

log("Comment LSO "

+ javaCodeOffsetToLineStartOffset(compilationUnit

.getLineNumber(comm.getStartPosition()),

comm.getStartPosition()));

break;

}

}*/

// Now parse the expression into an ASTNode object

ASTNode nearestNode;

ASTParser parser = ASTParser.newParser(AST.JLS8);

parser.setKind(ASTParser.K_EXPRESSION);

parser.setSource(phrase.toCharArray());

ASTNode testnode = parser.createAST(null);

//Base.loge("PREDICTION PARSER PROBLEMS: " + parser);

// Find closest ASTNode of the document to this word

Messages.loge("Typed: " + phrase + "|" + " temp Node type: " + testnode.getClass().getSimpleName());

if(testnode instanceof MethodInvocation){

MethodInvocation mi = (MethodInvocation)testnode;

log(mi.getName() + "," + mi.getExpression() + "," + mi.typeArguments().size());

}

// find nearest ASTNode

nearestNode = findClosestNode(lineNumber, astRootNode);

if (nearestNode == null) {

// Make sure nearestNode is not NULL if couldn't find a closest node

nearestNode = astRootNode;

}

Messages.loge(lineNumber + " Nearest ASTNode to PRED "

+ getNodeAsString(nearestNode));

candidates = new ArrayList<>();

lastPredictedPhrase = phrase;

// Determine the expression typed

if (testnode instanceof SimpleName && !noCompare) {

Messages.loge("One word expression " + getNodeAsString(testnode));

//==> Simple one word exprssion - so is just an identifier

// Bottom up traversal of the AST to look for possible definitions at

// higher levels.

//nearestNode = nearestNode.getParent();

while (nearestNode != null) {

// If the current class has a super class, look inside it for

// definitions.

if (nearestNode instanceof TypeDeclaration) {

TypeDeclaration td = (TypeDeclaration) nearestNode;

if (td.getStructuralProperty(TypeDeclaration.SUPERCLASS_TYPE_PROPERTY) != null) {

SimpleType st = (SimpleType) td.getStructuralProperty(TypeDeclaration.SUPERCLASS_TYPE_PROPERTY);

log("Superclass " + st.getName());

ArrayList<CompletionCandidate> tempCandidates =

getMembersForType(st.getName().toString(), phrase, false, false);

for (CompletionCandidate can : tempCandidates) {

candidates.add(can);

}

//findDeclaration(st.getName())

}

}

List<StructuralPropertyDescriptor> sprops =

nearestNode.structuralPropertiesForType();

for (StructuralPropertyDescriptor sprop : sprops) {

ASTNode cnode;

if (!sprop.isChildListProperty()) {

if (nearestNode.getStructuralProperty(sprop) instanceof ASTNode) {

cnode = (ASTNode) nearestNode.getStructuralProperty(sprop);

CompletionCandidate[] types = checkForTypes(cnode);

if (types != null) {

for (CompletionCandidate type : types) {

if (type.getElementName().toLowerCase().startsWith(phrase.toLowerCase()))

candidates.add(type);

}

}

}

} else {

// Childlist prop

List<ASTNode> nodelist =

(List<ASTNode>) nearestNode.getStructuralProperty(sprop);

for (ASTNode clnode : nodelist) {

CompletionCandidate[] types = checkForTypes(clnode);

if (types != null) {

for (CompletionCandidate type : types) {

if (type.getElementName().toLowerCase().startsWith(phrase.toLowerCase()))

candidates.add(type);

}

}

}

}

}

nearestNode = nearestNode.getParent();

}

// We're seeing a simple name that's not defined locally or in

// the parent class. So most probably a pre-defined type.

log("Empty can. " + phrase);

if (classPath != null) {

RegExpResourceFilter regExpResourceFilter =

new RegExpResourceFilter(Pattern.compile(".*"),

Pattern.compile(phrase + "[a-zA-Z_0-9]*.class",

Pattern.CASE_INSENSITIVE));

String[] resources = classPath.findResources("", regExpResourceFilter);

for (String matchedClass2 : resources) {

matchedClass2 = matchedClass2.replace('/', '.'); //package name

String matchedClass = matchedClass2.substring(0, matchedClass2.length() - 6);

int d = matchedClass.lastIndexOf('.');

if (!errorCheckerService.ignorableSuggestionImport(matchedClass)) {

matchedClass = matchedClass.substring(d + 1); //class name

// display package name in grey

String html = "<html>" + matchedClass + " : <font color=#777777>" +

matchedClass2.substring(0, d) + "</font></html>";

candidates.add(new CompletionCandidate(matchedClass, html,

matchedClass,

CompletionCandidate.PREDEF_CLASS));

}

}

}

} else {

// ==> Complex expression of type blah.blah2().doIt,etc

// Have to resolve it by carefully traversing AST of testNode

Messages.loge("Complex expression " + getNodeAsString(testnode));

log("candidates empty");

ASTNode childExpr = getChildExpression(testnode);

log("Parent expression : " + getParentExpression(testnode));

log("Child expression : " + childExpr);

if (!noCompare) {

log("Original testnode " + getNodeAsString(testnode));

testnode = getParentExpression(testnode);

log("Corrected testnode " + getNodeAsString(testnode));

}

ClassMember expr =

resolveExpression3rdParty(nearestNode, testnode, noCompare);

if (expr == null) {

log("Expr is null");

} else {

boolean isArray = expr.thisclass != null && expr.thisclass.isArray();

boolean isSimpleType = (expr.astNode != null) &&

expr.astNode.getNodeType() == ASTNode.SIMPLE_TYPE;

boolean isMethod = expr.method != null;

boolean staticOnly = !isMethod && !isArray && !isSimpleType;

log("Expr is " + expr.toString());