Changeset 5c182b6e475d5851c54cdb2117f25af21723b62a

Timestamp:

06/29/09 07:06:59 (8 months ago)

Author:

mb0 <mb0@…>

Parents:

2aa064d78a2c1162da70e2413b7c386278a1473d

Children:

8a0050b3611b877b0c6c480dc26f48d9afa9c369

git-committer:

mb0 <mb0@mb0.org> / 2009-06-29T07:06:59Z+0200

Message:

memory clean up ! (and several minor fixes)

• merged symboltablevisitor and indexingvisitor together with some basic syntax checks to form as3analysis
  
• index0r can now be used to request details on demand.
  
• axdoc parser ignores whitespace textnodes and now parses the member code span
  
• axdoc model: moved level property to indexnode and changed it to be persisted
  
• changed axlevel literals
  
• discover memory leak http://bugs.eclipse.org/281790, cleaned up with editor service.
  
• moved usefull generally useful methods out of as3 content proposer into as3 source helper
  
• when no index exists for a source folder the project will be built and cached.
  
• builder does not cache anymore instead builds two times. the first time to index. the second time to resolve.
  
• lexer helper error detection fixed ater working through the sparce documentation on lpgs deterministic parser.
  
• moved top level symbol table to the program ast node
  
• some minor parser changed
  

Files:

• org.axdt.as3.test/src/org/axdt/as3/imp/parser/BasicParserTest.java (modified) (6 diffs)
• org.axdt.as3.test/src/org/axdt/as3/imp/parser/ExpressionTest.java (modified) (1 diff)
• org.axdt.as3.test/src/org/axdt/as3/imp/parser/IndexingVisitorTest.java (added)
• org.axdt.as3.test/src/org/axdt/as3/imp/parser/ParseUtil.java (modified) (2 diffs)
• org.axdt.as3.test/src/org/axdt/as3/imp/parser/VirtualSemiTest.java (modified) (1 diff)
• org.axdt.as3/src/org/axdt/as3/AS3Plugin.java (modified) (3 diffs)
• org.axdt.as3/src/org/axdt/as3/analysis/AS3Analysis.java (added)
• org.axdt.as3/src/org/axdt/as3/analysis/AS3TokenHelper.java (added)
• org.axdt.as3/src/org/axdt/as3/imp/builders/AS3Builder.java (modified) (9 diffs)
• org.axdt.as3/src/org/axdt/as3/imp/parser/AS3LexHelper.java (modified) (6 diffs)
• org.axdt.as3/src/org/axdt/as3/imp/parser/AS3Lexer.gi (modified) (1 diff)
• org.axdt.as3/src/org/axdt/as3/imp/parser/AS3ParseController.java (modified) (10 diffs)
• org.axdt.as3/src/org/axdt/as3/imp/parser/AS3Parser.g (modified) (11 diffs)
• org.axdt.as3/src/org/axdt/as3/imp/parser/DiagnoseVisitor.java (modified) (4 diffs)
• org.axdt.as3/src/org/axdt/as3/imp/parser/IndexingVisitor.java (deleted)
• org.axdt.as3/src/org/axdt/as3/imp/parser/ResolvingVisitor.java (modified) (12 diffs)
• org.axdt.as3/src/org/axdt/as3/imp/parser/SymbolTable.java (modified) (3 diffs)
• org.axdt.as3/src/org/axdt/as3/imp/parser/SymbolTableVisitor.java (deleted)
• org.axdt.as3/src/org/axdt/as3/imp/services/AS3ContentProposer.java (modified) (11 diffs)
• org.axdt.as3/src/org/axdt/as3/imp/services/AS3EditorService.java (modified) (3 diffs)
• org.axdt.as3/src/org/axdt/as3/imp/services/AS3ReferenceResolver.java (modified) (2 diffs)
• org.axdt.as3/src/org/axdt/as3/imp/services/AS3SourceHelper.java (added)
• org.axdt.as3/src/org/axdt/as3/imp/services/AS3TokenColorer.java (modified) (2 diffs)
• org.axdt.as3/src/org/axdt/as3/util/AS3ASTUtil.java (modified) (4 diffs)
• org.axdt.as3/src/org/axdt/as3/util/DocTrimmerUtil.java (added)
• org.axdt.axdoc.model/model/AXDoc.ecore (modified) (3 diffs)
• org.axdt.axdoc.model/model/AXDocXML.xsd (modified) (1 diff)
• org.axdt.axdoc.model/src/org/axdt/axdoc/model/AXDocPackage.java (modified) (14 diffs)
• org.axdt.axdoc.model/src/org/axdt/axdoc/model/AXIndex.java (modified) (2 diffs)
• org.axdt.axdoc.model/src/org/axdt/axdoc/model/AXIndexNode.java (modified) (2 diffs)
• org.axdt.axdoc.model/src/org/axdt/axdoc/model/AXLevel.java (modified) (8 diffs)
• org.axdt.axdoc.model/src/org/axdt/axdoc/model/impl/AXDocPackageImpl.java (modified) (7 diffs)
• org.axdt.axdoc.model/src/org/axdt/axdoc/model/impl/AXEntryImpl.java (modified) (6 diffs)
• org.axdt.axdoc.model/src/org/axdt/axdoc/model/impl/AXIndexImpl.java (modified) (8 diffs)
• org.axdt.axdoc.model/src/org/axdt/axdoc/model/impl/AXIndexNodeImpl.java (modified) (9 diffs)
• org.axdt.axdoc.model/src/org/axdt/axdoc/model/impl/AXRootImpl.java (modified) (4 diffs)
• org.axdt.axdoc.test/src/org/axdt/axdoc/util/Index0rTest.java (modified) (1 diff)
• org.axdt.axdoc/src/org/axdt/axdoc/util/AXDocParser.java (modified) (12 diffs)
• org.axdt.axdoc/src/org/axdt/axdoc/util/Index0r.java (modified) (10 diffs)
• org.axdt.common/src/org/axdt/util/IFlexErrorCodes.java (modified) (1 diff)

org.axdt.as3.test/src/org/axdt/as3/imp/parser/BasicParserTest.java

@@ -19 +19 @@
 import org.axdt.as3.imp.parser.Ast.StringLiteral;
 import org.axdt.as3.imp.parser.Ast.VariableDefinition;
+import org.axdt.as3.imp.parser.ParseUtil.ParserContext;
 
 public class BasicParserTest extends TestCase {
-        private AS3Parser parser;
+        private ParserContext context;
         private Program parse(String content) {
-                parser = ParseUtil.parser(content);
-                return ParseUtil.parse(parser,0);
+                context = ParseUtil.parser(content);
+                return context.parse(0);
         }
         private <T extends IDirective> T assertFirstDirective(String string, Class<T> clazz) {
-                parser = ParseUtil.parser(string);
-                Program result = ParseUtil.parse(parser,0);
+                context = ParseUtil.parser(string);
+                Program result = context.parse(0);
                 return assertFirstDirective(result, clazz);
         }
@@ -38 +39 @@
                 } else {
                         // TODO gather some info
-                        ArrayList tokens = parser.getIPrsStream().getTokens();
+                        ArrayList tokens = context.parser.getIPrsStream().getTokens();
                         assertNotNull("parser error "+ tokens.toString(),prog);
                 }
@@ -79 +80 @@
 
                 // bom works just as expected
-                assertNotNull(parse("\u00ef\u00bb\u00bf package {}"));
+                prog = parse("\u00ef\u00bb\u00bf package {}");
+                assertNotNull(prog);
                 System.out.print("expected");
-                assertNull(parse("package \u00ef\u00bb\u00bf {}"));
+                prog = parse("package \u00ef\u00bb\u00bf {}");
+                // when using parseActions used as unicode package name ?!
+            assertNull(prog);
                 
                 prog = parse("package P{} package Q{}");
@@ -93 +97 @@
                 System.out.print("expected");
                 prog = parse("package P{} function f(){} package Q{}");
+                // when using parseActions finds the first package but fails to parse the following directives 
                 assertNull(prog);
         }
@@ -157 +162 @@
                 def = assertFirstDirective("function f():void{}",FunctionDefinition.class);
 
-                def = assertFirstDirective("function f(b:B){a = b;a.c();}",FunctionDefinition.class);
+                def = assertFirstDirective("function f(a:A,b:B){a = b;a.c();}",FunctionDefinition.class);
                 assertEquals("f", def.getName().toString());
                 assertEquals(2, def.getBlock().getDirectives().size());
                 FunctionCommon common = def.getCommon();
                 assertEquals(null, common.getResultType());
+                assertEquals(2, common.getParameters().size());
 
                 def = assertFirstDirective("function f(){}",FunctionDefinition.class);
@@ -171 +177 @@
                 def = assertFirstDirective("function get f(i){}",FunctionDefinition.class);
                 def = assertFirstDirective("function get f(a:A,b:B){}",FunctionDefinition.class);
-                // TODO fix parameter declaration
                 def = assertFirstDirective("function set(){}",FunctionDefinition.class);
                 def = assertFirstDirective("function get(a,b){}",FunctionDefinition.class);

org.axdt.as3.test/src/org/axdt/as3/imp/parser/ExpressionTest.java

@@ -122 +122 @@
                 assertExpression(parse("i..x"), Query.class);
                 assertExpression(parse("i..x::y"), Query.class);
-                assertExpression(parse("i.(@a::y.c)"), Query.class);
+                assertExpression(parse("i.(y,x)"), Query.class);
+                assertExpression(parse("i.(y)"), Query.class);
                 assertExpression(parse("i++"), PostIncrementExpression.class);
                 assertExpression(parse("i--"), PostDecrementExpression.class);
+                assertExpression(parse("i..(y)::id"), Query.class);
+                assertExpression(parse("i..@(y)::id"), Query.class);
+                assertExpression(parse("i..@[0]"), Query.class);
         }
         public void testNew() throws Exception {

org.axdt.as3.test/src/org/axdt/as3/imp/parser/ParseUtil.java

@@ -20 +20 @@
         }
         public static Program parse(String content, int repair) {
-                AS3Parser parser = parser(content);
-                return parse(parser,repair);
+                ParserContext context = parser(content);
+                return context.parse(repair);
         }
         public static Program parse(AS3Parser parser, int repair) {
@@ -29 +29 @@
                 return null;
         }
-        public static AS3Parser parser(String content) {
+        public static ParserContext parser(String content) {
                 char[] charArray = content.toCharArray();
-                AS3Lexer lexer = new AS3Lexer();
-                lexer.reset(charArray, "name");
-                AS3Parser parser = new AS3Parser();
-                parser.reset(lexer.getILexStream());
-                lexer.lexer(null, parser);
-                return parser;
+                ParserContext context = new ParserContext(charArray);
+                context.lex();
+                return context;
+        }
+        public static class ParserContext {
+                public AS3Lexer lexer = new AS3Lexer();
+                public AS3Parser parser = new AS3Parser();
+                public boolean lexSuccess;
+                
+                public ParserContext(char[] charArray) {
+                        lexer.reset(charArray, "name");
+                        parser.reset(lexer.getILexStream());
+                }
+                public Program parse(int repair) {
+                        Object result = null;
+                        if (lexSuccess) {
+                                result = parser.parserActions(null, repair);
+                        } else {
+                                result = parser.parser(null, repair);
+                        }
+                        return result instanceof Program ? (Program) result : null; 
+                }
+                public boolean lex() {
+                        lexSuccess = lexer.lexer(null, parser);
+                        return lexSuccess;
+                }
         }
 }

org.axdt.as3.test/src/org/axdt/as3/imp/parser/VirtualSemiTest.java

@@ -1 +1 @@
 package org.axdt.as3.imp.parser;
 
+import java.util.ArrayList;
+
 import org.axdt.as3.imp.parser.Ast.Program;
+import org.axdt.as3.imp.parser.ParseUtil.ParserContext;
 
 import junit.framework.TestCase;
+import lpg.runtime.IToken;
 
 public class VirtualSemiTest extends TestCase {
 
-        public static Program parse(String content) {
-                return ParseUtil.parse(content, 0);
+        @SuppressWarnings("unchecked")
+        public void assertVSemiInsertion(String content, int expected) {
+                ParserContext context = ParseUtil.parser(content);
+                Program parse = context.parse(-1);
+                assertNotNull(parse);
+                ArrayList<IToken> tokens = context.parser.getIPrsStream().getTokens();
+                int result = 0;
+                for (IToken t:tokens) {
+                        if (t.getKind() == AS3Parsersym.TK_VirtualSemicolon)
+                                result++;
+                }
+                assertEquals(expected, result);
         }
         public void testLineBreakVirtualSemi() throws Exception {
-                // TODO check that the parser should not insert v semi
-                assertNotNull(parse("{var i = 0;\nvar j = 1;}"));
-                // TODO dont insert if there is a semi 
-                assertNotNull(parse("{var i = 0\n;var j = 1;}"));
-                assertNotNull(parse("{var i = 0\nvar j = 1;}"));
+                // check that the parser should not insert v semi
+                assertVSemiInsertion("{var i = 0;\nvar j = 1;}",0);
+                // dont insert if there is a semi 
+                assertVSemiInsertion("{var i = 0\n;var j = 1;}",0);
+                assertVSemiInsertion("{var i = 0\nvar j = 1;}",1);
         }
         public void testGrammarVirtualSemi() throws Exception {
                 // abbrev semi is inserted before RCURLY or EOF
-                assertNotNull(parse("var j = 1"));
-                assertNotNull(parse("var j = 1;"));
-                assertNotNull(parse("{var i = 0;var j = 1}"));
+                assertVSemiInsertion("var j = 1",1);
+                assertVSemiInsertion("var j = 1;",0);
+                assertVSemiInsertion("{var i = 0;var j = 1}",1);
         }
 }

org.axdt.as3/src/org/axdt/as3/AS3Plugin.java

@@ -4 +4 @@
 import java.net.URL;
 
+import org.axdt.as3.imp.builders.AS3Builder;
 import org.axdt.as3.imp.builders.AS3Nature;
 import org.axdt.as3.preferences.AS3Preferences;
 import org.axdt.as3.templates.AS3ContextType;
-import org.axdt.axdoc.model.AXRootType;
+import org.axdt.axdoc.model.AXRoot;
 import org.axdt.axdoc.util.Index0r;
 import org.axdt.common.preferences.AxdtPreferences;
 import org.eclipse.core.resources.IContainer;
 import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IncrementalProjectBuilder;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.FileLocator;
 import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.preferences.ConfigurationScope;
 import org.eclipse.core.runtime.preferences.IScopeContext;
-import org.eclipse.emf.common.util.URI;
 import org.eclipse.imp.runtime.PluginBase;
 import org.eclipse.jface.preference.IPreferenceStore;
@@ -161 +163 @@
         
         private void initializeIndex() {
+                IProgressMonitor monitor = null;
                 Index0r index0r = Index0r.getInstance();
                 // asdoc locations are added on axdoc plugin start
@@ -172 +175 @@
                         }
                         IContainer[] paths = AS3Preferences.getSourcePaths(project);
+                        boolean needsBuild = false;
                         for (IContainer srcPath:paths) {
                                 if (!srcPath.exists()) continue;
-                                String name = "source "+srcPath.getFullPath();
-                                URI uri = URI.createPlatformResourceURI(srcPath.getFullPath().toString(), true);
-                                index0r.addRoot(name, uri.toString(), AXRootType.SOURCE);
+                                AXRoot root = index0r.addSourceRoot(srcPath);
+                                try {
+                                        needsBuild = needsBuild || root.eContents().isEmpty() && srcPath.members().length > 0;
+                                } catch (CoreException e) {/* ignore */ }
+                                index0r.saveRoot(root);
+                                index0r.cachePackages(root);
+                        }
+                        if (needsBuild) {
+                                try {
+                                        project.build(IncrementalProjectBuilder.FULL_BUILD, AS3Builder.BUILDER_ID, null, monitor);
+                                } catch (CoreException e) {
+                                        log("error invoking initial build", e);
+                                }
                         }
                 }

org.axdt.as3/src/org/axdt/as3/imp/builders/AS3Builder.java

@@ -1 +1 @@
 package org.axdt.as3.imp.builders;
 
-import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
@@ -8 +9 @@
 import org.axdt.as3.AS3Plugin;
 import org.axdt.as3.imp.parser.AS3ParseController;
+import org.axdt.as3.imp.parser.ResolvingVisitor;
+import org.axdt.as3.imp.parser.Ast.ASTNode;
 import org.axdt.as3.preferences.AS3Preferences;
-import org.axdt.as3.util.AS3Util;
 import org.axdt.axdoc.model.AXRoot;
 import org.axdt.axdoc.util.Index0r;
@@ -16 +18 @@
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
+import org.eclipse.core.resources.IResourceDelta;
+import org.eclipse.core.resources.IResourceDeltaVisitor;
+import org.eclipse.core.resources.IResourceVisitor;
+import org.eclipse.core.resources.IncrementalProjectBuilder;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.SubProgressMonitor;
 import org.eclipse.core.runtime.content.IContentDescription;
-import org.eclipse.imp.builder.BuilderBase;
 import org.eclipse.imp.builder.BuilderUtils;
 import org.eclipse.imp.builder.MarkerCreator;
@@ -28 +34 @@
 import org.eclipse.imp.model.ModelFactory;
 import org.eclipse.imp.model.ModelFactory.ModelException;
+import org.eclipse.imp.parser.IMessageHandler;
 import org.eclipse.imp.runtime.PluginBase;
 import org.eclipse.imp.services.IAnnotationTypeInfo;
@@ -36 +43 @@
  * "Build" a project.
  */
-public class AS3Builder extends BuilderBase {
-
+public class AS3Builder extends IncrementalProjectBuilder {
         public static final String BUILDER_ID = AS3Plugin.PLUGIN_ID + ".imp.builder";
         public static final String PROBLEM_MARKER_ID = AS3Plugin.PLUGIN_ID + ".imp.builder.problem";
         public static final Language LANGUAGE = LanguageRegistry.findLanguage(AS3Plugin.LANGUAGE);
-        private boolean isFullBuild = false;
-        private List<AS3ParseController> astnodes;
-
-        public AS3Builder() {
-                super();
-        }
+        
+        protected Index0r fIndex0r;
+        protected Collection<IFile> fSourcesToCompile;
+        protected IContainer fDeployContainer;
+        protected IContainer[] fSourceContainer;
 
         protected PluginBase getPlugin() {
@@ -56 +61 @@
         }
 
-        protected String getWarningMarkerID() {
-                return PROBLEM_MARKER_ID;
-        }
-
-        protected String getInfoMarkerID() {
-                return PROBLEM_MARKER_ID;
-        }
-
-        /**
-         * Decide whether a file needs to be build using this builder. Note that
-         * <code>isNonRootSourceFile()</code> and <code>isSourceFile()</code>
-         * should never return true for the same file.
-         * 
-         * @return true if an arbitrary file is a AS3 source file.
-         */
-        protected boolean isSourceFile(IFile file) {
-                IPath path = file.getRawLocation();
-                if (path == null || !LANGUAGE.hasExtension(path.getFileExtension())) 
-                        return false;
-                IContainer sourceFolder = AS3Util.getSourceFolder(file);
-                return sourceFolder != null;
-        }
-
-        /**
-         * Decide whether or not to scan a file for dependencies. Note:
-         * <code>isNonRootSourceFile()</code> and <code>isSourceFile()</code>
-         * should never return true for the same file.
-         * 
-         * @return true if the given file is a source file that this builder should
-         *         scan for dependencies, but not compile as a top-level compilation
-         *         unit.
-         */
-        protected boolean isNonRootSourceFile(IFile resource) {
-                return false;
-        }
-
-        /**
-         * Collects compilation-unit dependencies for the given file, and records
-         * them via calls to <code>fDependency.addDependency()</code>.
-         */
-        protected void collectDependencies(IFile file) {
-                // TODO: implement dependency collector
-                // fDependencyInfo.addDependency(fromPath, uponPath);
-        }
-
-        /**
-         * @return true if this resource identifies the output folder
-         */
-        protected boolean isOutputFolder(IResource resource) {
-                if (resource == null || !(resource instanceof IContainer)) return false;
-                return resource.equals(AS3Preferences.getDeployPath(resource));
-        }
+        protected void initBuilder(int kind, Map args) {
+                fIndex0r = Index0r.getInstance();
+                fSourcesToCompile = new HashSet<IFile>();
+                fDeployContainer = AS3Preferences.getDeployPath(getProject());
+                fSourceContainer = AS3Preferences.getSourcePaths(getProject());
+        }
+
+        protected void clearBuilder() {
+                fIndex0r = null;
+                fSourcesToCompile = null;
+                fDeployContainer = null;
+                fSourceContainer = null;
+        }
+        
         @Override
         @SuppressWarnings("unchecked")
         protected IProject[] build(int kind, Map args, IProgressMonitor monitor) {
-                isFullBuild  = kind == FULL_BUILD || kind == CLEAN_BUILD;
-                if (isFullBuild) {
-                        Index0r index0r = Index0r.getInstance();
-                        IContainer[] srcFolders = AS3Preferences.getSourcePaths(getProject());
-                        for (IContainer srcFolder:srcFolders) {
-                                AXRoot root = index0r.getSourceRoot(srcFolder);
-                                index0r.clearRoot(root);
+                monitor.beginTask("Building",51);
+                try {
+                        initBuilder(kind, args);
+                        monitor.worked(1);
+                        boolean isFullBuild  = kind == FULL_BUILD || kind == CLEAN_BUILD;
+                        SubProgressMonitor subMonitor = new SubProgressMonitor(monitor,50,SubProgressMonitor.PREPEND_MAIN_LABEL_TO_SUBTASK);
+                        if (isFullBuild) {
+                                buildFull(args, subMonitor);
+                        } else {
+                                buildChanged(args, subMonitor);
                         }
-                        astnodes = new ArrayList<AS3ParseController>();
+                } finally {
+                        clearBuilder();
+                        monitor.done();
+                }
+                return new IProject[0];
+        }
+        private void buildChanged(Map args, IProgressMonitor monitor) {
+                monitor.beginTask(" changed Resources", 11);
+                try {
+                        IResourceDelta delta = getDelta(getProject());
+                        if (delta != null) {
+                                delta.accept(new SourceDeltaVisitor());
+                        } else {
+                                getProject().accept(new SourceCollectVisitor());
+                        }
+                        monitor.worked(1);
+                        SubProgressMonitor subMonitor = new SubProgressMonitor(monitor,10,SubProgressMonitor.SUPPRESS_SUBTASK_LABEL);
+                        compileNecessarySources(subMonitor);
+                } catch (CoreException e) {
+                        AS3Plugin.getDefault().debug("Error collecting sources", e);
+                } finally {
+                        monitor.done();
+                }
+        }
+
+        private void buildFull(Map args, IProgressMonitor monitor) {
+                monitor.beginTask(" all Resources", 13);
+                try {
+                        getProject().accept(new SourceCollectVisitor());
+                        monitor.worked(1);
+                        clearIndex();
+                        monitor.worked(1);
                         // do the build. it should index the whole project
-                        super.build(kind, args, monitor);
-                        for (AS3ParseController control:astnodes) {
-                                control.resolveDeclarations(control.getCurrentAst());
-                        }
-                        astnodes = null;
+                        SubProgressMonitor subMonitor = new SubProgressMonitor(monitor,10,SubProgressMonitor.SUPPRESS_SUBTASK_LABEL);
+                        compileNecessarySources(subMonitor);
                         // build done save and cache the index
-                        for (IContainer srcFolder:srcFolders) {
-                                AXRoot root = index0r.getSourceRoot(srcFolder);
-                                index0r.saveRoot(root);
-                                index0r.cachePackages(root);
-                        }
-                        return new IProject[0];
-                } else {
-                        // proceed with normal build
-                        return super.build(kind, args, monitor);
-                }
-        }
+                        cacheIndex();
+                        monitor.worked(1);
+                } catch (Exception e) {
+                        AS3Plugin.getDefault().debug("Error collecting sources", e);
+                } finally {
+                        monitor.done();
+                }
+        }
+    protected void compileNecessarySources(IProgressMonitor monitor) {
+                monitor.beginTask("", fSourcesToCompile.size()*2);
+                try {
+                        // first we lex and parse once without resolving or error reporting
+                for(IFile file : fSourcesToCompile) {
+                    clearMarkersOn(file);
+                    compile(file, new SubProgressMonitor(monitor,1), false);
+                }
+                // the second time the index is build and we can resolve after parsing
+                for(IFile file : fSourcesToCompile) {
+                    clearMarkersOn(file);
+                    compile(file, new SubProgressMonitor(monitor,1), true);
+                }
+                // the reason to parse the files twice is that caching is to expensive (mem peak)
+                // and cpu cycles cheap enough. the ideal solution would be a cheap and clean 
+                // dependency analysis.
+                } finally {
+                        monitor.done();
+                }
+    }
+
+        protected void cacheIndex() {
+                for (IContainer srcFolder:fSourceContainer) {
+                        AXRoot root = fIndex0r.getSourceRoot(srcFolder);
+                        fIndex0r.saveRoot(root);
+                        fIndex0r.cachePackages(root);
+                }
+        }
+
+        protected void clearIndex() {
+                for (IContainer folder:fSourceContainer) {
+                        AXRoot root = fIndex0r.getSourceRoot(folder);
+                        fIndex0r.clearRoot(root);
+                }
+        }
+
+        protected void clearMarkersOn(IFile file) {
+        try {
+                file.deleteMarkers(getErrorMarkerID(), true, IResource.DEPTH_INFINITE);
+        } catch (CoreException e) {
+        }
+    }
+
         /**
          * Compile one AS3 file.
          * It will not actually compile, but analyze and index the model.
          */
-        protected void compile(final IFile file, IProgressMonitor monitor) {
-                AS3ParseController parse = getParseController(file);
+        protected void compile(IFile file, IProgressMonitor monitor, boolean resolve) {
+                AS3ParseController parse = getParseController(file, resolve);
                 // if controller could not be created or initialized 
                 if (parse == null || parse.getProject() == null) 
                         return;
+                monitor.beginTask("", 10);
+                try {
+                        parse.parse(getContents(file), resolve, new SubProgressMonitor(monitor,10));
+                } finally {
+                        parse.dispose();
+                        monitor.done();
+                }
+        }
+        
+        protected String getContents(IFile file) {
                 String contents = BuilderUtils.getFileContents(file);
-                if (hasBom(file)) contents = removeBom(contents);
-                Object ast = parse.parse(contents, false, monitor);
-                if (ast != null && astnodes != null) {
-                        astnodes.add(parse);
-                }
-        }
-
-        private String removeBom(String contents) {
+                return hasBom(file) ? removeBom(contents) : contents;
+        }
+
+        protected String removeBom(String contents) {
                 // first char might be misread utf8 char
                 return contents.charAt(0) == 0xfeff ?   
@@ -161 +205 @@
         }
 
-        private boolean hasBom(IFile file) {
+        protected boolean hasBom(IFile file) {
                 try {
                         IContentDescription info = file.getContentDescription();
@@ -170 +214 @@
 
         @SuppressWarnings("unchecked")
-        private AS3ParseController getParseController(IFile file) {
+        protected AS3ParseController getParseController(IFile file, boolean reportErrors) {
                 AS3ParseController controller = new AS3ParseController();
-                IAnnotationTypeInfo typeInfo = controller.getAnnotationTypeInfo();
+                addMarkerTypeOnce(controller.getAnnotationTypeInfo());
+                IMessageHandler marker = reportErrors ? new MarkerCreator(file, controller, PROBLEM_MARKER_ID)
+                                                                        : null;
+                IPath relativePath = file.getProjectRelativePath();
+                try {
+                        ISourceProject sourceProject = ModelFactory.open(file.getProject());
+                        controller.initialize(relativePath, sourceProject, marker);
+                } catch (ModelException e) {
+                        getPlugin().logException("Cannot create parse controller", e);
+                }
+                return controller;
+        }
+        private void addMarkerTypeOnce(IAnnotationTypeInfo typeInfo) {
                 List<List<String>> lists = Arrays.asList(typeInfo.getProblemMarkerTypes());
                 boolean found = false;
@@ -182 +238 @@
                 }
                 if (!found) typeInfo.addProblemMarkerType(getErrorMarkerID());
-                MarkerCreator marker = new MarkerCreator(file, controller, PROBLEM_MARKER_ID);
-                IPath relativePath = file.getProjectRelativePath();
-                try {
-                        ISourceProject sourceProject = ModelFactory.open(file.getProject());
-                        controller.initialize(relativePath, sourceProject, marker);
-                } catch (ModelException e) {
-                        getPlugin().logException("Cannot create parse controller", e);
-                }
-                return controller;
-        }
-        @Override
-        protected void clearMarkersOn(IFile file) {
-                try {
-            file.deleteMarkers(getErrorMarkerID(), true, IResource.DEPTH_INFINITE);
-        } catch (CoreException e) {
-        }
-                //super.clearMarkersOn(file);
+        }
+
+        protected class SourceCollectVisitor implements IResourceVisitor {
+                public boolean visit(IResource resource) throws CoreException {
+                        return processResource(resource, fSourcesToCompile);
+                }
+        }
+        protected class SourceDeltaVisitor implements IResourceDeltaVisitor {
+        public boolean visit(IResourceDelta delta) throws CoreException {
+            return processResource(delta.getResource(), fSourcesToCompile);
+        }
+    }
+        protected boolean processResource(IResource resource, Collection<IFile> result) {
+                if (resource instanceof IFile) {
+                        IFile file = (IFile) resource;
+                        if (isSourceFile(file)) result.add(file);
+                } else if (resource.equals(fDeployContainer)) {
+                        return false;
+                }
+                return true;
+        }
+        public boolean isSourceFile(IFile file) {
+                if (file != null && file.exists() && LANGUAGE.hasExtension(file.getFileExtension()))
+                        for (IContainer folder:fSourceContainer)
+                                if (folder.getFullPath().isPrefixOf(file.getFullPath()))
+                                        return true;
+                return false;
         }
 }
+class CustomResolvingVisitor extends ResolvingVisitor {
+        private ASTNode node;
+        public CustomResolvingVisitor(IFile myfile, ASTNode node) {
+                super(myfile, node.getLeftIToken().getILexStream());
+                this.node = node;
+        }
+        public void run() {
+                node.accept(this);
+        }
+}

org.axdt.as3/src/org/axdt/as3/imp/parser/AS3LexHelper.java

@@ -63 +63 @@
                         HelperAst ast = parseXml(offset);
                         return tryAst(ast, AS3Parsersym.TK_Xml);
-                } else
-                        errorDetected();
+                }
                 return false;
         }
@@ -74 +73 @@
                         HelperAst ast = parseRegex(offset);
                         return tryAst(ast, AS3Parsersym.TK_RegularExpression);
-                } else
-                        errorDetected();
+                }
                 return false;
         }
@@ -84 +82 @@
                 prs.makeToken(ast.start, ast.end, kind);
                 lexer.getParser().resetTokenStream(ast.end + 1);
+                prs.reset(ast.end + 1);
                 return true;
         }
@@ -146 +145 @@
                 boolean isNewLine = detectedLineBreak;
                 detectedLineBreak = false;
-                if (hasError(kind)) {
-                        int lastKind = getKind(getLast());
-                        switch (kind) {
-                        case AS3Parsersym.TK_LPAREN:
-                                if (lastKind == AS3Parsersym.TK_get
-                                                || lastKind == AS3Parsersym.TK_set) {
-                                        parser.errorReset();
-                                        getLast().setKind(AS3Parsersym.TK_IDENTIFIER);
-                                }
+                boolean checkAgain = true;
+                int lastKind = getKind(getLast());
+                boolean found = false;
+                switch (kind) {
+                case AS3Parsersym.TK_get:
+                case AS3Parsersym.TK_set:
+                        if (lastKind == AS3Parsersym.TK_function) {
+                                int c = lex.getIntValue(e+1);
+                                for (int i=e+2;Character.isWhitespace(c);i++) {
+                                        // TODO: also skip comments
+                                        c = lex.getCharValue(i);
+                                }
+                                if (Character.isJavaIdentifierStart(c)) {
+                                        break;
+                                }
+                        }
+                        found = true;
+                case AS3Parsersym.TK_namespace:
+                case AS3Parsersym.TK_each:
+                case AS3Parsersym.TK_include:
+                case AS3Parsersym.TK_xml:
+                        if (!found && !hasError(kind)) {
+                                checkAgain = false;
                                 break;
-                        case AS3Parsersym.TK_get:
-                        case AS3Parsersym.TK_set:
-                                if (getKind(getLast()) == AS3Parsersym.TK_function) {
-                                        break;
-                                }
-                        case AS3Parsersym.TK_each:
-                        case AS3Parsersym.TK_namespace:
-                        case AS3Parsersym.TK_include:
-                        case AS3Parsersym.TK_xml:
-                                if (!hasError(AS3Parsersym.TK_IDENTIFIER)) {
-                                        kind = AS3Parsersym.TK_IDENTIFIER;
-                                }
-                                break;
-                        }
+                        }
+                        if (!hasError(AS3Parsersym.TK_IDENTIFIER)) {
+                                checkAgain = false;
+                                kind = AS3Parsersym.TK_IDENTIFIER;
+                        }
+                }
+                if (checkAgain && hasError(kind)) {
                         if (isNewLine) {
                                 // line-break semicolon insertion
@@ -183 +189 @@
                                         int end = getLast().getEndOffset();
                                         prs.makeToken(end + 1, end, AS3Parsersym.TK_NO_LINE_BREAK);
-                                } else
-                                        errorDetected();
-                        }
+                                }
+                        }
+                        if (tryXmlOrRegex(kind,s)) return;
                         if (hasError(kind))
                                 errorDetected();
-                }
+                } else if (tryXmlOrRegex(kind, s)) {
+                        return;
+                }
+                prs.makeToken(s, e, kind);
+        }
+        private boolean tryXmlOrRegex(int kind, int s) {
                 switch (kind) {
                 // check for xml
                 case AS3Parsersym.TK_LT:
-                        if (tryXml(s))
-                                return;
-                        else
-                                break;
+                        return tryXml(s);
                         // check for regex
                 case AS3Parsersym.TK_DIV:
                 case AS3Parsersym.TK_DIV_ASSIGN:
-                        if (tryRegex(s))
-                                return;
-                        else
-                                break;
-                }
-                prs.makeToken(s, e, kind);
-        }
-
+                        return tryRegex(s);
+                }
+                return false;
+        }
         private void tryToInsertSemicolon() {
                 if (!hasError(AS3Parsersym.TK_VirtualSemicolon)) {
@@ -212 +216 @@
                         prs.makeToken(end + 1, end, AS3Parsersym.TK_VirtualSemicolon);
                         insertedVirtualSemicolons++;
-                } else
-                        errorDetected();
+                }
         }
 

org.axdt.as3/src/org/axdt/as3/imp/parser/AS3Lexer.gi

@@ -632 +632 @@
                 lexParser.parseCharacters(monitor);
                 make.eof();
-                return !make.detectedError;
+                boolean hadErrors = make.detectedError;
+                make = null;
+                return !hadErrors;
             }
             public int [] getKeywordKinds() {

org.axdt.as3/src/org/axdt/as3/imp/parser/AS3ParseController.java

@@ -4 +4 @@
 import java.util.Iterator;
 
-import lpg.runtime.IAst;
-
 import org.axdt.as3.AS3Plugin;
+import org.axdt.as3.analysis.AS3Analysis;
 import org.axdt.as3.imp.parser.Ast.ASTNode;
 import org.axdt.as3.imp.services.AS3SyntaxProperties;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
-import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.imp.model.ISourceProject;
 import org.eclipse.imp.parser.ILexer;
@@ -33 +31 @@
         private IPath location;
 
-        private SymbolTable topLevelSymbolTable = null;
+        private AS3Analysis analysis;
 
         public AS3ParseController() {
@@ -77 +75 @@
          */
         public Object parse(String contents, boolean resolve, IProgressMonitor monitor) {
-                if (monitor == null) monitor = new NullProgressMonitor();
+                //if (monitor == null) monitor = new NullProgressMonitor();
                 int newHash = contents.hashCode();
                 if (lastHash == newHash) {
@@ -85 +83 @@
                 AS3Plugin.getDefault().debug("parsing "+ getPath().toString());
                 lastHash = newHash;
-                topLevelSymbolTable = null;
                 PMMonitor my_monitor = new PMMonitor(monitor);
                 char[] contentsArray = contents.toCharArray();
@@ -96 +93 @@
 
                 if (parser == null) {
-                        parser = new AS3Parser(lexer.getILexStream());
+                        parser = new AS3Parser();
                 }
                 parser.reset(lexer.getILexStream());
@@ -102 +99 @@
 
                 // Lex the stream to produce the token stream
-                lexer.lexer(my_monitor, parser); 
+                boolean success = lexer.lexer(my_monitor, parser); 
                 // fCurrentAst might (probably will) be
                 // inconsistent wrt the lex stream now
@@ -109 +106 @@
                 if (fCurrentAst != null)
                         backupAst = fCurrentAst;
+                if (success) {
+                        // the lexer called the deterministic parser incrementally and we can just assemble the ast
+                        fCurrentAst = parser.parserActions(my_monitor, 0);
+                } else {
+                        // do parseActions anyway we have no other way to clear the deterministicparser.action field
+                        // and we have a memory leak otherwise
+                        parser.parserActions(my_monitor, 0);
+                        fCurrentAst = parser.parser(my_monitor, -1);
+                }
+                if (fCurrentAst != null)
+                        backupAst = null;
+                
+                if (analysis == null)
+                        analysis = new AS3Analysis(this);
+                analysis.analyse(fCurrentAst);
 
-                fCurrentAst = parser.parser(my_monitor, -1);
-
-                if (fCurrentAst instanceof ASTNode) {
+                if (resolve && fCurrentAst instanceof ASTNode) {
                         ASTNode node = (ASTNode) fCurrentAst;
-                        topLevelSymbolTable = resolveSymbolTable(node);
-                        buildIndex(node);
-                        if (resolve) {
-                                resolveDeclarations(node);
-                        }
+                        resolveDeclarations(node);
                 }
 
@@ -124 +130 @@
 
                 return fCurrentAst;
-        }
-        
-        public void buildIndex(Object object) {
-                if (object instanceof ASTNode) {
-                        ((ASTNode)object).accept(new IndexingVisitor(this));
-                }
         }
         
@@ -138 +138 @@
         }
 
-        protected SymbolTable resolveSymbolTable(ASTNode root) {
-                SymbolTableVisitor symbolTableVisitor = new SymbolTableVisitor(this);
-                root.accept(symbolTableVisitor);
-                return symbolTableVisitor.getTopLevelSymbolTable();
-        }
-
         public Object getBackupAst() {
                 return backupAst;
-        }
-
-        public SymbolTable getEnclosingSymbolTable(IAst node) {
-                if (topLevelSymbolTable  != null) {
-                        return topLevelSymbolTable.getEnclosingSymbolTable(node);
-                }
-                return null;
         }
 
@@ -161 +148 @@
                 return super.getTokenIterator(region);
         }
+
+        public void dispose() {
+                parser = null;
+                lexer = null;
+                backupAst = null;
+                fCurrentAst = null;
+                handler = null;
+                analysis = null;
+        }
 }

org.axdt.as3/src/org/axdt/as3/imp/parser/AS3Parser.g

@@ -487 +487 @@
           | Statement_sif
           | VariableDefinition_allowin
-          | Attributes --NO_LINE_BREAK$ 
-                LCURLY$ Substatements RCURLY$
+--        | Attributes --NO_LINE_BREAK$ 
+--              LCURLY$ Substatements RCURLY$
 
 Substatement_nosif$Substatement
@@ -494 +494 @@
           | Statement_nosif
           | VariableDefinition_allowin
-          | Attributes --NO_LINE_BREAK$ 
-                LCURLY$ Substatements RCURLY$
-
-Substatements$Substatements$Substatement ::= %empty
-Substatements$Substatements$Substatement ::= Substatements Substatement_sif
+--        | Attributes --NO_LINE_BREAK$ 
+--              LCURLY$ Substatements RCURLY$
+
+--Substatements$Substatements$Substatement ::= %empty
+--Substatements$Substatements$Substatement ::= Substatements Substatement_sif
 
 -- no empty semicolon ! use virtual semi instead !
@@ -521 +521 @@
 Block$Block ::= LCURLY$ RCURLY$
 /.
-        public static final int OTHER = 0;
-        public static final int METHOD = 4;
-        public static final int FUNCTION = 5;
-        public static final int PACKAGE = 1;
-        public static final int CLASS = 2;
-        public static final int INTERFACE = 3;
-        public int type;
         SymbolTable symbolTable;
         public void setSymbolTable(SymbolTable symbolTable) { this.symbolTable = symbolTable; }
@@ -626 +619 @@
 AnnotatedDirective
         ::= Attributes --NO_LINE_BREAK$ 
-                AnnotatableDirective
-          | AnnotatableDirective
+                AnnotatableDirective$Directive
+          | AnnotatableDirective$Directive
 Directive ::= AnnotatedDirective
           | EmptyStatment
@@ -710 +703 @@
 VariableBindingList_noin$VariableBindingsNoin$VariableBinding_noin ::= VariableBindingList_noin COMMA$ VariableBinding_noin
 
-VariableBindingList ::= VariableBindingList_allowin | VariableBindingList_noin
+
  --B
 VariableBinding_allowin$VariableBinding 
@@ -766 +759 @@
 -- 17.2.1 Function body
 FunctionCommon$FunctionCommon ::= LPAREN$ Parameters RPAREN$ ResultType
+FunctionCommon$FunctionCommon ::= LPAREN$ RPAREN$ ResultType
 
 -- 17.2.2 Function signature
 
 -- 17.2.3 Parameter list 
-Parameters$Parameters$Parameter ::= %empty
-Parameters$Parameters$Parameter ::= NonemptyParameters
-NonemptyParameters$Parameters$Parameter ::= Parameter
-NonemptyParameters$Parameters$Parameter ::= PlainParameter COMMA$ NonemptyParameters
+Parameters$Parameters$Parameter ::= Parameter
+-- rest is only allowed as last parameter but check that later
+Parameters$Parameters$Parameter ::= Parameter COMMA$ Parameters
 Parameter ::= PlainParameter | RestParameter
 PlainParameter$PlainParameter ::= TypedIdentifier_allowin$Ident
 PlainParameter$PlainParameter ::= TypedIdentifier_allowin$Ident ASSIGN$ AssignmentExpression_allowin$Initializer
 RestParameter$RestParameter ::= REST$
-RestParameter$RestParameter ::= REST$ Identifier$Untyped
 RestParameter$RestParameter ::= REST$ TypedIdentifier_allowin$Ident
 
@@ -826 +818 @@
 InterfaceDefinition ::= interface$ Name ExtendsList InterfaceBlock$Body
 /.
+        SymbolTable symbolTable;
+        public void setSymbolTable(SymbolTable symbolTable) { this.symbolTable = symbolTable; }
+        public SymbolTable getSymbolTable() { return symbolTable; }
         public Attributes getAttributes() {
                 if (!(getParent() instanceof AnnotatedDirective)) return null;
@@ -842 +837 @@
 InterfaceBlock$InterfaceBlock ::= LCURLY$ RCURLY$
 InterfaceBlock$InterfaceBlock ::= LCURLY$ InterfaceDirectives$Directives RCURLY$
-/.
-        SymbolTable symbolTable;
-        public void setSymbolTable(SymbolTable symbolTable) { this.symbolTable = symbolTable; }
-        public SymbolTable getSymbolTable() { return symbolTable; }
-./
+
 InterfaceDirectives$InterfaceDirectives$FunctionSignature ::= FunctionSignature
 InterfaceDirectives$InterfaceDirectives$FunctionSignature ::= InterfaceDirectives FunctionSignature
@@ -874 +865 @@
                 return _Packages.getPackageDefinitionAt(0);
         }
+        SymbolTable symbolTable;
+        public void setSymbolTable(SymbolTable symbolTable) { this.symbolTable = symbolTable; }
+        public SymbolTable getSymbolTable() { return symbolTable; }
 ./
 
@@ -883 +877 @@
 VariableDefinition ::= VariableDefinition_allowin | VariableDefinition_noin
 VariableBinding ::= VariableBinding_allowin | VariableBinding_noin
+VariableBindingList ::= VariableBindingList_allowin | VariableBindingList_noin
 Statement ::= Statement_sif | Statement_nosif
 Substatement ::= Substatement_sif | Substatement_nosif
@@ -890 +885 @@
 %Headers
 /.
+    public Object parserActions(Monitor monitor, int error_repair_count)
+    {
+        dtParser.setMonitor(monitor);
+
+        try
+        {
+            return (Object) dtParser.parseActions();
+        }
+        catch (BadParseException e)
+        {
+            prsStream.reset(e.error_token); // point to error token
+
+            DiagnoseParser diagnoseParser = new DiagnoseParser(prsStream, prsTable);
+            diagnoseParser.diagnose(e.error_token);
+        }
+
+        return null;
+    }
 ./
 %End

org.axdt.as3/src/org/axdt/as3/imp/parser/DiagnoseVisitor.java

@@ -1 +1 @@
 package org.axdt.as3.imp.parser;
 
+import lpg.runtime.IAst;
 import lpg.runtime.ILexStream;
 import lpg.runtime.IMessageHandler;
-import lpg.runtime.IPrsStream;
 import lpg.runtime.IToken;
 import lpg.runtime.ParseErrorCodes;
 
-import org.axdt.as3.imp.parser.Ast.ASTNode;
 import org.axdt.as3.imp.parser.Ast.AbstractVisitor;
 import org.eclipse.core.resources.IFile;
@@ -13 +12 @@
 
 public class DiagnoseVisitor extends AbstractVisitor {
-        protected static int[] NULL_LOCATION = new int[] {0,0};
+        protected static int[] NULL_LOCATION = null;
         
-        protected final IPrsStream prsStream;
         protected final ILexStream lexStream;
-        protected AS3ParseController parseController;
-        protected int errorCount = 0;
+        protected final IFile file;
+        
+        public int errorCount = 0;
         protected boolean severeError = false;
 
-        public DiagnoseVisitor(AS3ParseController parseController) {
-                this.parseController = parseController;
-                this.prsStream = parseController.getParser().getIPrsStream();
-                this.lexStream = prsStream.getILexStream();
+        public DiagnoseVisitor(IFile file, ILexStream stream) {
+                this.file = file;
+                this.lexStream = stream;
         }
 
         protected IProject getProject() {
-                return parseController.getProject().getRawProject();
+                return file.getProject();
         }
         
         protected IFile getFile() {
-                return getProject().getFile(parseController.getPath());
+                return file;
+        }
+
+        public void emitError(Object node, String message) {
+                emitError((IAst) node, message);
         }
 
@@ -39 +41 @@
         }
 
-        public void emitError(ASTNode node, String message) {
+        public void emitError(IAst node, String message) {
                 emitError(node.getLeftIToken().getStartOffset(), node.getRightIToken().getEndOffset(), message);
         }
@@ -46 +48 @@
                 emitError(ParseErrorCodes.NO_MESSAGE_CODE, startOffset, endOffset, message);
         }
+
+        public void emitError(int code, IToken id, String message) {
+                emitError(code, id.getStartOffset(), id.getEndOffset(), message);
+        }
+
+        public void emitError(int code, IAst node, String message) {
+                emitError(code, node.getLeftIToken().getStartOffset(), node.getRightIToken().getEndOffset(), message);
+        }
         public void emitError(int code, int startOffset, int endOffset, String message) {
-                int[] loc = lexStream.getLocation(startOffset, endOffset);
+                int[] loc = lexStream.getLocation(Math.min(startOffset,lexStream.getStreamLength()), Math.min(endOffset, lexStream.getStreamLength()));
+                if (NULL_LOCATION == null)
+                        NULL_LOCATION = lexStream.getLocation(0, 0);
                 String[] msgs = new String[] {message};
                 IMessageHandler handler = lexStream.getMessageHandler();
-                handler.handleMessage(code, loc, NULL_LOCATION, prsStream.getFileName(), msgs);
+                handler.handleMessage(code, loc, NULL_LOCATION, file.getName(), msgs);
                 errorCount++;
         }

org.axdt.as3/src/org/axdt/as3/imp/parser/ResolvingVisitor.java

@@ -5 +5 @@
 
 import lpg.runtime.IAst;
+import lpg.runtime.ILexStream;
 
 import org.axdt.as3.AS3Plugin;
@@ -14 +15 @@
 import org.axdt.as3.imp.parser.Ast.ExtendsList;
 import org.axdt.as3.imp.parser.Ast.FunctionDefinition;
-import org.axdt.as3.imp.parser.Ast.FunctionExpression;
 import org.axdt.as3.imp.parser.Ast.IName;
-import org.axdt.as3.imp.parser.Ast.IPostfixExpression;
 import org.axdt.as3.imp.parser.Ast.ITypeExpression_allowin;
-import org.axdt.as3.imp.parser.Ast.ITypeExpression_noin;
 import org.axdt.as3.imp.parser.Ast.Ident;
 import org.axdt.as3.imp.parser.Ast.ImportDirective;
@@ -24 +22 @@
 import org.axdt.as3.imp.parser.Ast.InterfaceDefinition;
 import org.axdt.as3.imp.parser.Ast.Name;
+import org.axdt.as3.imp.parser.Ast.NewExpression;
 import org.axdt.as3.imp.parser.Ast.PackageDefinition;
+import org.axdt.as3.imp.parser.Ast.Parameters;
+import org.axdt.as3.imp.parser.Ast.RestParameter;
 import org.axdt.as3.imp.parser.Ast.ResultType;
 import org.axdt.as3.imp.parser.Ast.TypeExpressionList;
 import org.axdt.as3.imp.parser.Ast.TypedIdentifier;
-import org.axdt.as3.imp.parser.Ast.VariableBinding;
+import org.axdt.as3.util.AS3ASTUtil;
 import org.axdt.as3.util.AS3Util;
 import org.axdt.axdoc.model.AXEntry;
@@ -35 +36 @@
 import org.axdt.axdoc.util.Index0r;
 import org.axdt.common.preferences.AxdtPreferences;
+import org.eclipse.core.resources.IFile;
 
 public class ResolvingVisitor extends DiagnoseVisitor {
@@ -42 +44 @@
         private ArrayList<AXEntry> importedTypes;
         private String expectedPackageName;
-
-        public ResolvingVisitor(AS3ParseController parseController) {
-                super(parseController);
+        public ResolvingVisitor(AS3ParseController pc) {
+                this(pc.getProject().getRawProject().getFile(pc.getPath()), pc.getLexer().getILexStream());
+        }
+        public ResolvingVisitor(IFile file, ILexStream stream) {
+                super(file, stream);
                 addDebugErrors = AS3Plugin.getDefault() != null && AxdtPreferences.doDebug();
                 index0r = Index0r.getInstance();
@@ -60 +64 @@
                         }
                 }
+                // add same package
                 AXIndex[] sameIndexes = index0r.findPackage(expectedPackageName);
                 for (AXIndex index:sameIndexes) {
                         importedPackages.add(index);
                 }
+                // file private names are resolved with the local symbol table
         }
         protected AXEntry resolveType(String name) {
                 for (AXEntry entry:importedTypes) {
-                        if (entry.getName().equals(name))
+                        if (entry.getName().equals(name)) {
+                                index0r.requestFull(entry);
                                 return entry;
+                        }
                 }
                 for (AXIndex index:importedPackages) {
                         for (AXEntry entry:index.getTypes()) {
                                 if (entry.getName().equals(name)) {
+                                        index0r.requestFull(entry);
                                         return entry;
                                 }
@@ -79 +88 @@
                 return null;
         }
-        protected String resolveType(ITypeExpression_noin type) {
+        protected Object resolveType(Object type) {
                 return type instanceof ASTNode ? resolveNode((ASTNode) type) : null;
         }
-        protected String resolveType(ITypeExpression_allowin type) {
-                return type instanceof ASTNode ? resolveNode((ASTNode) type) : null;
-        }
-        protected String resolveType(IPostfixExpression type) {
-                return type instanceof ASTNode ? resolveNode((ASTNode) type) : null;
-        }
-        protected String resolveNode(ASTNode type) {
-                if (type == null) 
-                        return null;
+        protected Object resolveConstructor(Object type) {
+                if (type == null) return null;
                 String typeName = type.toString();
                 AXEntry entry = resolveType(typeName);
-                if (entry == null) {
-                        if (!typeName.equals("*"))
-                                emitError((ASTNode)type, "could not resolve type");
-                        return null;
-                }
-                String id = entry.getId();
-                if (type instanceof Ident) {
-                        ((Ident)type).setDeclaration(id);
-                } else if (addDebugErrors) {
-                        emitError((ASTNode)type, "todo: not expected other than ident");
-                }
-                return id;
+                Object declaration = null;
+                if (entry != null) {
+                        AXEntry member = entry.localMember(typeName);
+                        if (member != null){
+                                declaration = member.getId();
+                        } else {
+                                declaration = entry.getId();
+                        }
+                } else {
+                        // might be file private member
+                        SymbolTable table = AS3ASTUtil.getEnclosingSymbolTable((IAst)type).getRoot();
+                        declaration = table.findDeclaration(typeName);
+                }
+                setDeclaration(type, declaration);
+                return declaration;
+        }
+        protected Object resolveNode(ASTNode type) {
+                if (type == null) return null;
+                Object declaration = null;
+                String typeName = type.toString();
+                if (typeName.equals("*")) {
+                        declaration = "*";
+                } else {
+                        AXEntry entry = resolveType(typeName);
+                        if (entry != null) {
+                                declaration = entry.getId();
+                        } else {
+                                // might be file private member
+                                SymbolTable table = AS3ASTUtil.getEnclosingSymbolTable(type).getRoot();
+                                declaration = table.findDeclaration(typeName);
+                        }
+                }
+                setDeclaration(type, declaration);
+                return declaration;
+        }
+        protected void setDeclaration(Object type, Object declaration) {
+                if (declaration != null) {
+                        if (type instanceof Ident) {
+                                ((Ident)type).setDeclaration(declaration);
+                        } else if (addDebugErrors) {
+                                emitError((ASTNode)type, "todo: not expected other than ident");
+                        }
+                } else {
+                        emitError((ASTNode)type, "could not resolve type");
+                }
         }
         protected void resolveTypes(TypeExpressionList list) {
@@ -121 +156 @@
         @Override
         public boolean visit(PackageDefinition n) {
-                String packageName = AS3Util.getExpectedPackageName(getFile());
-                // is not inside a valid source path
-                if (packageName == null) {
-                        emitError(n, "file should be inside a configured source path");
-                        return false;
-                }
-                // check if name corresponds with folder names
-                if (n.getName() != null) {
-                        Name nameNode = (Name) n.getName();
-                        String name = nameNode.toString();
-                        if (!name.equals(packageName))
-                                emitError(nameNode, "package name sould be: "+ packageName);
-                        // fill declaration with false
-                        Name current = nameNode;
-                        while (current!=null) {
-                                current.getIdent().setDeclaration(Boolean.FALSE);
-                                current = current.getQualifier() instanceof Name ?
-                                                (Name)current.getQualifier() : null;
-                        }
-                } else if (packageName != null && packageName.length() > 0) {
-                        emitError(n.getLeftIToken(), "package name sould be: "+ packageName);
-                }
                 return true;
         }
@@ -187 +200 @@
         }
         @Override
-        public boolean visit(ClassDefinition n) {
-                Name name = (Name) n.getName();
-                checkTypeName(name);
-                checkPackageDirectiveName(name);
-                return true;
-        }
-        @Override
         public boolean visit(Inheritance n) {
                 ClassDefinition parent = (ClassDefinition) n.getParent();
@@ -202 +208 @@
         }
         @Override
-        public boolean visit(InterfaceDefinition n) {
-                Name name = (Name) n.getName();
-                checkTypeName(name);
-                checkPackageDirectiveName(name);
-                return true;
-        }
-        @Override
         public boolean visit(ExtendsList n) {
                 InterfaceDefinition parent = (InterfaceDefinition) n.getParent();
@@ -214 +213 @@
                 return false;
         }
-        private void checkTypeName(Name name) {
-                if (name.getQualifier()!=null)
-                        emitError(name, "type names are not qualified. the package name belongs in the package declaration");
-                name.getIdent().setDeclaration(Boolean.FALSE);
-        }
-        private void checkPackageDirectiveName(Name name) {
-                IAst grandp = name;
-                while (grandp != null) {
-                        grandp = grandp.getParent();
-                        if (grandp instanceof PackageDefinition)
-                                break;
-                }
-                if (grandp != null) {
-                        String nameString = name.getIdent().toString();
-                        String expectedName = AS3Util.getExpectedMemberName(getFile());
-                        if (!nameString.equals(expectedName)) 
-                                emitError(name, "public package member name should match the file name");
-                }
-        }
         
+        @Override
+        public boolean visit(FunctionDefinition n) {
+                Ident name = n.getName();
+                if (name == null) {
+                        emitError(n, "must have a name");
+                        // TODO check for overrides ?
+                        // 
+                }
+                return true;
+        }
+        @Override
+        public boolean visit(RestParameter n) {
+                // TODO: move to more basic checking phase 
+                IAst parent = n.getParent();
+                if (parent instanceof Parameters) {
+                        Parameters params = (Parameters) parent;
+                        if (n != params.getParameterAt(params.size()-1)) {
+                                emitError(n, "rest parameter can only occur as last parameter");
+                        }
+                } else {
+                        emitError(parent, "todo: rest parameters parent should be parameters ?!");
+                }
+                return true;
+        }
+        @Override
         public boolean visit(TypedIdentifier n) {
-                if (n != null)
+                if (n != null) {
                         resolveNode(n.getType());
-                return false;
-        }
+                        n.getName().setDeclaration(Boolean.FALSE);
+                }
+                return false;
+        }
+        @Override
         public boolean visit(ResultType n) {
                 if (n != null)
@@ -244 +252 @@
                 return false;
         }
-
+        @Override
+        public void endVisit(NewExpression n) {
+                // TODO check expression for type
+                if (n != null) {
+                        resolveConstructor(n.getExpression());
+                }
+        }
+        @Override
+        public void endVisit(AssignmentExpression n) {
+                // TODO check if left type is assignable from right type
+                n.toString();
+        }
+        @Override
+        public boolean visit(ExpressionStatement n) {
+                return true;
+        }
 }

org.axdt.as3/src/org/axdt/as3/imp/parser/SymbolTable.java

@@ -2 +2 @@
 
 import java.util.ArrayList;
-import java.util.Hashtable;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import lpg.runtime.IAst;
 
-import org.axdt.as3.imp.parser.Ast.Block;
-import org.axdt.as3.imp.parser.Ast.ClassDefinition;
-import org.axdt.as3.imp.parser.Ast.FunctionDefinition;
-import org.axdt.as3.imp.parser.Ast.FunctionExpression;
-import org.axdt.as3.imp.parser.Ast.InterfaceBlock;
+import org.axdt.as3.util.AS3ASTUtil;
 
-public class SymbolTable extends Hashtable<String, IAst> {
+public class SymbolTable {
+        public class SymbolEntry {
+
+                private IAst node;
+
+                public SymbolEntry(IAst node) {
+                        this.node = node;
+                }
+
+                public IAst getAst() {
+                        return node;
+                }
+
+        }
         private static final long serialVersionUID = 1L;
-        SymbolTable parent;
-        Class<?> nodeClass;
+        private Map<String,SymbolEntry> store;
+        private SymbolTable parent;
+        private Class<?> nodeClass;
         
-        SymbolTable(SymbolTable parent, Class<?> clazz) {
+        public SymbolTable(SymbolTable parent, Class<?> clazz) {
                 this.parent = parent;
                 this.nodeClass = clazz;
+                store = new HashMap<String, SymbolEntry>();
         }
 
         public IAst findDeclaration(String name) {
-                IAst decl = (IAst) get(name);
-                if (decl != null) return decl;
+                SymbolEntry entry = store.get(name);
+                if (entry != null) return entry.getAst();
                 if (parent != null) return parent.findDeclaration(name);
                 return null;
@@ -33 +45 @@
                 return parent;
         }
+        public SymbolTable getRoot() {
+                return parent == null ? this : parent.getRoot();
+        }
 
         public boolean create(String name, IAst node) {
-                if (get(name) == null) {
-                        put(name, node);
+                if (store.get(name) == null) {
+                        store.put(name, new SymbolEntry(node));
                         return true;
                 }
@@ -45 +60 @@
                 if (list == null)
                         list = new ArrayList<String>();
-                list.addAll(keySet());
+                list.addAll(store.keySet());
                 if (parent != null) parent.getAllKeys(list);
                 return list;
         }
         public SymbolTable getEnclosingSymbolTable(IAst n) {
-                SymbolTable enclosing = getEnclosing(n);
+                SymbolTable enclosing = AS3ASTUtil.getEnclosingSymbolTable(n);
                 if (enclosing != null) return enclosing;
                 return this;
-        }
-        public static SymbolTable getEnclosing(IAst n) {
-                for (; n != null; n = n.getParent()) {
-                        if (n instanceof Block) return ((Block) n).getSymbolTable();
-                        if (n instanceof InterfaceBlock) return ((InterfaceBlock) n).getSymbolTable();
-                        if (n instanceof FunctionDefinition) return ((FunctionDefinition) n).getSymbolTable();
-                        if (n instanceof FunctionExpression) return ((FunctionExpression) n).getSymbolTable();
-                        if (n instanceof ClassDefinition) return ((ClassDefinition) n).getSymbolTable();
-                }
-                return null;
         }
         public String cleanName(String key) {

org.axdt.as3/src/org/axdt/as3/imp/services/AS3ContentProposer.java

@@ -7 +7 @@
 
 import lpg.runtime.IAst;
-import lpg.runtime.IPrsStream;
-import lpg.runtime.IToken;
 
-import org.axdt.as3.AS3Plugin;
-import org.axdt.as3.imp.parser.AS3ASTNodeLocator;
+import org.axdt.as3.analysis.AS3TokenHelper;
 import org.axdt.as3.imp.parser.AS3ParseController;
-import org.axdt.as3.imp.parser.AS3Parsersym;
 import org.axdt.as3.imp.parser.SymbolTable;
 import org.axdt.as3.imp.parser.Ast.ASTNode;
-import org.axdt.as3.imp.parser.Ast.IAnnotatableDirective;
 import org.axdt.as3.imp.parser.Ast.IName;
 import org.axdt.as3.imp.parser.Ast.ImportDirective;
 import org.axdt.as3.imp.parser.Ast.PackageDefinition;
 import org.axdt.as3.templates.AS3TemplateCompletionProcessor;
+import org.axdt.as3.util.AS3ASTUtil;
 import org.axdt.as3.util.AS3Util;
 import org.axdt.axdoc.model.AXEntry;
@@ -28 +24 @@
 import org.eclipse.imp.editor.SourceProposal;
 import org.eclipse.imp.parser.IParseController;
-import org.eclipse.imp.parser.IParser;
 import org.eclipse.imp.services.IContentProposer;
 import org.eclipse.jface.text.ITextViewer;
@@ -35 +30 @@
 public class AS3ContentProposer implements IContentProposer {
         
-        private static AS3ASTNodeLocator locator = new AS3ASTNodeLocator();
+        private AS3SourceHelper helper;
         
-        private boolean offsetWithinToken;
-        private int offset;
-        private AS3ParseController control;
-        private IToken token;
-        private String prefix;
-        private ASTNode ast;
-        private ASTNode node;
-
-        private ArrayList<IAst> ancestors;
-
-        private IToken previous;
-
-        private IToken next;
-
-        private boolean offsetAfterToken;
-
-        private ITextViewer viewer;
-
-        private boolean usingBackup;
-
-        private int originalOffset;
-
-
-        private int offsetDiff;
-
-        private boolean nextIsSemi;
-        
-        private void clear() {
-                offsetWithinToken = offsetAfterToken = nextIsSemi = false;
-                prefix = null; 
-                ancestors = null;
-                token = previous = next = null;
-                node = null;
-        }
-
         public AS3ContentProposer() {
-        }
-        protected boolean collectInfo(IParseController controller, int offset, ITextViewer viewer) {
-                this.viewer = viewer;
-                this.control = (AS3ParseController) controller;
-                this.offset = offset;
-                offsetDiff = offset - originalOffset;
-                usingBackup = false;
-                ast = null;
-                ASTNode newast = getAst();
-                if (newast != null && newast == ast) {
-                        AS3Plugin.getDefault().debug("using old ast nothing changed");
-                        return true;
-                }
-                IParser parser = control.getParser();
-                IPrsStream stream = parser.getIPrsStream();
-                if (stream == null)  {
-                        AS3Plugin.getDefault().debug("no error lexing.");
-                        return false;
-                }
-                if (newast == null) {
-                        AS3Plugin.getDefault().debug("no ast available try to recover");
-                        Object backupAst = control.getBackupAst();
-                        if (! (backupAst instanceof ASTNode)) {
-                                AS3Plugin.getDefault().debug("no backup ast. recover failed.");
-                                return false;
-                        }
-                        newast = (ASTNode) backupAst;
-                        usingBackup = true;
-                } else {
-                        originalOffset = offset;
-                }
-                clear();
-                try {
-                        ast = newast;
-                        int myOffset = offset;
-                        int index = stream.getTokenIndexAtCharacter(myOffset);
-                        token = getToken(stream, index < 0 ? -index + 1: index);
-                        previous = getToken(stream, token.getTokenIndex()-1);
-                        offsetAfterToken = previous.getEndOffset() == myOffset - 1;
-                        if (offsetAfterToken || token.getKind() == Sym.TK_SEMI 
-                                || (myOffset < token.getStartOffset()&& stream.getILexStream().getLineNumberOfCharAt(myOffset) < token.getLine())) {
-                                next = token;
-                                token = previous;
-                                previous = stream.getIToken(token.getTokenIndex()-1);
-                        }
-                        if (next == null){
-                                next = stream.getIToken(stream.getNext(token.getTokenIndex()));
-                        }
-                        nextIsSemi = next.getKind() == Sym.TK_SEMI;
-                        offsetWithinToken = Sym.isWithinToken(myOffset, token);
-                        if ((offsetAfterToken||offsetWithinToken) && Sym.isKeyword(token)) 
-                                return false;
-                        this.prefix = offsetWithinToken ? Sym.getPrefix(myOffset, token) 
-                                        : ( offsetAfterToken ? token.toString() : "");
-                        node = getNode(token);
-                        collectAncestorInfo(node);
-                } catch (Exception e) {
-                        AS3Plugin.getDefault().debug("error collecting context info for completion proposals", e);
-                }
-                return true;
-        }
-        private IToken getToken(IPrsStream s, int index) {
-                IToken result = s.getIToken(index);
-                if (result.getKind() == Sym.TK_VirtualSemicolon)
-                        result = s.getIToken(index-1);
-                return result;
-        }
-        private void collectAncestorInfo(ASTNode node) {
-                ancestors = new ArrayList<IAst>();
-                for (IAst n = node; n != null; n = n.getParent()) {
-                        if (n instanceof IAnnotatableDirective
-                         || n instanceof ImportDirective
-                         || n instanceof PackageDefinition
-                         ) {
-                                ancestors.add(n);
-                        }
-                }
-        }
-        private ASTNode getNode(IToken t) {
-                Object object = locator.findNode(ast, t.getStartOffset(), t.getEndOffset());
-                return (object instanceof ASTNode) ? (ASTNode) object : null;
-        }
-        private ASTNode getAst() {
-                Object object = control.parse(viewer.getDocument().get(), null);
-                return (object instanceof ASTNode) ? (ASTNode) object : null;
         }
         /**
@@ -180 +55 @@
         public ICompletionProposal[] getContentProposals(IParseController controller, int offset,
                         ITextViewer viewer) {
-                boolean precede = collectInfo(controller, offset, viewer);
+                helper = new AS3SourceHelper((AS3ParseController)controller, viewer);
+                boolean precede = helper.init(offset);
                 if (!precede) {
                         return new ICompletionProposal[0];
                 }
                 ProposalHelper proposals = new ProposalHelper();
-                if (ast != null) {
-                        if (ancestors != null && ancestors.size() > 0) {
-                                IAst ancestor = ancestors.get(0);
+                if (helper.hasAst()) {
+                        if (helper.hasAncestors()) {
+                                IAst ancestor = helper.ancestors.get(0);
                                 if (ancestor instanceof PackageDefinition) {
                                         PackageDefinition packdef = (PackageDefinition)ancestor;
-                                        if (packdef.getBody() == null || offset < packdef.getBody().getLeftIToken().getStartOffset()+offsetDiff) {
+                                        if (packdef.getBody() == null || offset <= packdef.getBody().getLeftIToken().getStartOffset()) {
                                                 // in package header
                                                 IName nameNode = packdef.getName();
-                                                if (!usingBackup)
-                                                        prefix = fetchName((IAst) nameNode);
-                                                IResource project = control.getProject().getResource();
-                                                String expectedName = AS3Util.getExpectedPackageName(project,project.getFullPath().append(control.getPath()));
-                                                if (!prefix.equals(expectedName))
-                                                        proposals.addSourceProposal(expectedName, prefix,PackageDefinition.class);
+                                                helper.updatePrefix(helper.fetchName((IAst) nameNode));
+                                                IResource project = helper.control.getProject().getResource();
+                                                String expectedName = AS3Util.getExpectedPackageName(project,project.getFullPath().append(helper.control.getPath()));
+                                                if (!helper.prefix.equals(expectedName))
+                                                        proposals.addSourceProposal(expectedName, helper.prefix,PackageDefinition.class);
                                         } else {
-                                                proposals.addUnitScopeProposals(node);
-                                                boolean isImport = token.getKind() == Sym.TK_import;
-                                                if (isImport || prefix.startsWith("import")) {
+                                                proposals.addUnitScopeProposals(helper.node);
+                                                boolean isImport = helper.token.getKind() == AS3TokenHelper.TK_import;
+                                                if (isImport || helper.prefix.startsWith("import")) {
                                                         for (String packname:Index0r.getInstance().getPackageNames()) {
                                                                 String proposed = (isImport ? "":"import ")+packname+".*";
-                                                                proposals.addSourceProposal(proposed, prefix, ImportDirective.class, !nextIsSemi);
+                                                                proposals.addSourceProposal(proposed, helper.prefix, ImportDirective.class, !helper.nextIsSemi());
                                                         }
                                                 }
@@ -211 +86 @@
                                 } else if (ancestor instanceof ImportDirective) {
                                         IName nameNode = ((ImportDirective)ancestor).getName();
-                                        if (!usingBackup)
-                                                prefix = fetchName((IAst) nameNode);
-                                        int dotIndex = prefix.lastIndexOf('.');
+                                        helper.updatePrefix(helper.fetchName((IAst) nameNode));
+                                        int dotIndex = helper.prefix.lastIndexOf('.');
                                         Collection<String> packageNames = Index0r.getInstance().getPackageNames();
                                         if (dotIndex > 0) {
-                                                String packname = prefix.substring(0,dotIndex);
-                                                String rest = prefix.substring(dotIndex+1);
+                                                String packname = helper.prefix.substring(0,dotIndex);
+                                                String rest = helper.prefix.substring(dotIndex+1);
                                                 if (packageNames.contains(packname)) {
                                                         if ("*".equals(rest)) {
@@ -226 +100 @@
                                                                         String entryname = entry.getName();
                                                                         if (entryname != null && (rest.length() == 0 || entryname.startsWith(rest))) {
-                                                                                proposals.addSourceProposal(packname+"."+entryname, prefix, ImportDirective.class, !nextIsSemi);
+                                                                                proposals.addSourceProposal(packname+"."+entryname, helper.prefix, ImportDirective.class, !helper.nextIsSemi());
                                                                         }
                                                                 }
                                                                 if (rest.length() == 0) {
-                                                                        proposals.addSourceProposal(packname+".*", prefix, ImportDirective.class, !nextIsSemi);
+                                                                        proposals.addSourceProposal(packname+".*", helper.prefix, ImportDirective.class, !helper.nextIsSemi());
                                                                 }
                                                         }
@@ -236 +110 @@
                                         }
                                         for (String packname:packageNames) {
-                                                if (packname.startsWith(prefix)) {
-                                                        proposals.addSourceProposal(packname+".*", prefix, ImportDirective.class, !nextIsSemi);
+                                                if (packname.startsWith(helper.prefix)) {
+                                                        proposals.addSourceProposal(packname+".*", helper.prefix, ImportDirective.class, !helper.nextIsSemi());
                                                 }
                                         }
                                 } else {
-                                        proposals.addUnitScopeProposals(node);
+                                        proposals.addUnitScopeProposals(helper.node);
                                 }
                         } else {
@@ -247 +121 @@
                         }
                 }
-                if (prefix != null && prefix.length() > 0) {
+                if (helper.hasPrefix()) {
                         proposals.addKeywordProposals();
                         proposals.addTemplateProposals(viewer);
                 }
                 return proposals.getResult();
-        }
-        protected String fetchName(IAst nameNode) {
-                String name = nameNode == null ? "" : nameNode.toString();
-                int startOffset = nameNode == null ? offset : nameNode.getLeftIToken().getStartOffset();
-                if (offset > startOffset + name.length()) {
-                        try {
-                                name = viewer.getDocument().get(startOffset, offset - startOffset);
-                        } catch (Exception e) {
-                                AS3Plugin.getDefault().debug("error fetching real name",e);
-                        }
-                }
-                return name;
         }
         public static final Comparator<ICompletionProposal> ProposalComparator = new Comparator<ICompletionProposal>() {
@@ -270 +132 @@
                 }
         };
-        private class ProposalHelper implements AS3Parsersym {
+        private class ProposalHelper {
                 ArrayList<ICompletionProposal> result = new ArrayList<ICompletionProposal>();
                 
                 void addUnitScopeProposals(ASTNode node) {
-                        SymbolTable table = SymbolTable.getEnclosing(node);
+                        SymbolTable table = AS3ASTUtil.getEnclosingSymbolTable(node);
                         if (table == null) return;
                         for (String key:table.getAllKeys(null)) {
                                 String name = table.cleanName(key);
-                                if (name.startsWith(prefix)) {
+                                if (name.startsWith(helper.prefix)) {
                                         IAst ast = table.findDeclaration(key);
-                                        result.add(new AS3SourceProposal(name, prefix, offset, ast.getClass()));
+                                        result.add(new AS3SourceProposal(name, helper.prefix, helper.offset, ast.getClass()));
                                 }
                         }
                 }
                 void addSourceProposal(String packageName, String usePrefix, ASTNode node) {
-                        result.add(new AS3SourceProposal(packageName, usePrefix, offset, node.getClass()));
+                        result.add(new AS3SourceProposal(packageName, usePrefix, helper.offset, node.getClass()));
                 }
                 void addSourceProposal(String packageName, String usePrefix, Class<?> nodeClass) {
-                        result.add(new AS3SourceProposal(packageName, usePrefix, offset, nodeClass));
+                        result.add(new AS3SourceProposal(packageName, usePrefix, helper.offset, nodeClass));
                 }
                 void addSourceProposal(String packageName, String usePrefix, Class<?> nodeClass, boolean addSemi) {
                         if (addSemi) packageName += ";";
-                        result.add(new AS3SourceProposal(packageName, usePrefix, offset, nodeClass));
+                        result.add(new AS3SourceProposal(packageName, usePrefix, helper.offset, nodeClass));
                 }
                 void addKeywordProposals() {
-                        for (String key:Sym.getKeyWords()) {
-                                if (!key.equals(prefix) && key.startsWith(prefix)) {
-                                        SourceProposal proposal = new SourceProposal(key, prefix, offset);
+                        for (String key:AS3TokenHelper.getKeyWords()) {
+                                if (!key.equals(helper.prefix) && key.startsWith(helper.prefix)) {
+                                        SourceProposal proposal = new SourceProposal(key, helper.prefix, helper.offset);
                                         result.add(proposal);
                                 }
@@ -304 +166 @@
                 void addTemplateProposals(ITextViewer viewer) {
                         AS3TemplateCompletionProcessor processor = new AS3TemplateCompletionProcessor();
-                        result.addAll(processor.computeCompletionProposalList(viewer, offset, prefix));
+                        result.addAll(processor.computeCompletionProposalList(viewer, helper.offset, helper.prefix));
                 }
                 ICompletionProposal[] getResult() {
@@ -311 +173 @@
                 }
         }
-        public static class Sym implements AS3Parsersym {
-                private static String[] keywords = null;
-                
-                public static String[] getKeyWords() {
-                        if (keywords == null)
-                                keywords = createKeywords();
-                        return keywords;
-                }
-                
-                public static boolean isKeyword(IToken t) {
-                        int kind = t.getKind();
-                        if (kind > 1 && kind < orderedTerminalSymbols.length) {
-                                return orderedTerminalSymbols[kind].charAt(0) > 'Z';
-                        }
-                        return false;
-                }
-
-                public static String getPrefix(int o, IToken t) {
-                        return t.getKind() == Sym.TK_IDENTIFIER ?
-                                        t.toString().substring(0, o-t.getStartOffset()) : "";
-                }
-
-                public static boolean isWithinToken(int o, IToken t) {
-                        return o >= t.getStartOffset() && o <= t.getEndOffset();
-                }
-                
-                private static String[] createKeywords() {
-                        ArrayList<String> result = new ArrayList<String>();
-                        for (int i = 1; i < orderedTerminalSymbols.length; i++) {
-                                if (orderedTerminalSymbols[i].charAt(0) > 'Z')
-                                        result.add(orderedTerminalSymbols[i]);
-                        }
-                        return result.toArray(new String[result.size()]);
-                }
-        }
 }

org.axdt.as3/src/org/axdt/as3/imp/services/AS3EditorService.java

@@ -6 +6 @@
 
 import org.axdt.as3.AS3Plugin;
+import org.axdt.as3.imp.parser.AS3ParseController;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
@@ -38 +39 @@
         public void update(IParseController parseController,
                         IProgressMonitor monitor) {
-                // TODO do update ?! we do the work in the as3 parse controller for now 
         }
 
@@ -71 +71 @@
                         if (editor != part) return;
                         partService.removePartListener(this);
-                        if (path != null)openFilePaths.remove(path);
+                        
+                        // clean up as long as there is the memory leak http://bugs.eclipse.org/281790
+                        editor.fParserScheduler.cancel();
+                        editor.fParserScheduler = null;
+                        if (editor.getParseController() instanceof AS3ParseController) {
+                                AS3ParseController control = ((AS3ParseController) editor.getParseController());
+                                control.dispose(); 
+                        }
+                        
+                        if (path != null) openFilePaths.remove(path);
                         AS3Plugin.getDefault().debug("as3 editor closed");
                 }

org.axdt.as3/src/org/axdt/as3/imp/services/AS3ReferenceResolver.java

@@ -3 +3 @@
 import lpg.runtime.IAst;
 
-import org.axdt.as3.imp.parser.AS3ParseController;
 import org.axdt.as3.imp.parser.SymbolTable;
 import org.axdt.as3.imp.parser.Ast.Ident;
@@ -58 +57 @@
 
         private Object lookInSymbolTable(IParseController controller, IAst node, String stringId) {
-                SymbolTable symtab = ((AS3ParseController) controller).getEnclosingSymbolTable(node);
+                SymbolTable symtab = AS3ASTUtil.getEnclosingSymbolTable(node);
                 return symtab.findDeclaration(stringId);
         }

org.axdt.as3/src/org/axdt/as3/imp/services/AS3TokenColorer.java

@@ -4 +4 @@
 import lpg.runtime.IToken;
 
-import org.axdt.as3.imp.parser.AS3ParseController;
+import org.axdt.as3.analysis.AS3TokenHelper;
 import org.axdt.as3.imp.parser.AS3Parsersym;
 import org.eclipse.imp.parser.IParseController;
@@ -40 +40 @@
                                 return null;
                         }
-                        if (((AS3ParseController) controller).isKeyword(token.getKind()))
+                        if (AS3TokenHelper.isKeyword(token))
                                 return keywordAttribute;
                         return super.getColoring(controller, token);

org.axdt.as3/src/org/axdt/as3/util/AS3ASTUtil.java

@@ -3 +3 @@
 import lpg.runtime.IAst;
 
+import org.axdt.as3.imp.parser.SymbolTable;
 import org.axdt.as3.imp.parser.Ast.ASTNode;
+import org.axdt.as3.imp.parser.Ast.Block;
+import org.axdt.as3.imp.parser.Ast.ClassDefinition;
+import org.axdt.as3.imp.parser.Ast.FunctionDefinition;
+import org.axdt.as3.imp.parser.Ast.FunctionExpression;
 import org.axdt.as3.imp.parser.Ast.IDirective;
 import org.axdt.as3.imp.parser.Ast.IPackageDefinition;
+import org.axdt.as3.imp.parser.Ast.ITypedIdentifier_noin;
 import org.axdt.as3.imp.parser.Ast.Ident;
+import org.axdt.as3.imp.parser.Ast.InterfaceDefinition;
 import org.axdt.as3.imp.parser.Ast.Name;
+import org.axdt.as3.imp.parser.Ast.Program;
 
 public class AS3ASTUtil {
@@ -13 +21 @@
                 return parent instanceof IDirective
                         || parent instanceof IPackageDefinition;
+        }
+        public static boolean isNameParent(IAst parent) {
+                return parent instanceof IDirective
+                        || parent instanceof IPackageDefinition
+                        || parent instanceof ITypedIdentifier_noin;
         }
         public static ASTNode getDirective(ASTNode node) {
@@ -37 +50 @@
                 }
                 if (Boolean.FALSE.equals(declaration)) {
-                        IAst parent = current.getParent();
-                        while (parent != null && !isDirective(parent.getParent()))
+                        IAst parent = current;
+                        while (parent != null && !isNameParent(parent.getParent()))
                                 parent = parent.getParent();
                         return parent;
@@ -44 +57 @@
                 return declaration;
         }
+        public static SymbolTable getEnclosingSymbolTable(IAst n) {
+                for (; n != null; n = n.getParent()) {
+                        if (n instanceof Block) return ((Block) n).getSymbolTable();
+                        if (n instanceof FunctionDefinition) return ((FunctionDefinition) n).getSymbolTable();
+                        if (n instanceof FunctionExpression) return ((FunctionExpression) n).getSymbolTable();
+                        if (n instanceof ClassDefinition) return ((ClassDefinition) n).getSymbolTable();
+                        if (n instanceof InterfaceDefinition) return ((InterfaceDefinition) n).getSymbolTable();
+                        if (n instanceof Program) return ((Program) n).getSymbolTable();
+                }
+                return null;
+        }
 }

org.axdt.axdoc.model/model/AXDoc.ecore

@@ -26 +26 @@
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EEnum" name="AXLevel">
-    <eLiterals name="EMPTY"/>
-    <eLiterals name="PACKAGE" value="1"/>
-    <eLiterals name="TYPE" value="2"/>
-    <eLiterals name="MEMBER" value="4"/>
+    <eLiterals name="EMPTY" literal="e"/>
+    <eLiterals name="PACKAGE" value="1" literal="p"/>
+    <eLiterals name="TYPE" value="2" literal="t"/>
+    <eLiterals name="MEMBER" value="4" literal="m"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EClass" name="AXIndex" eSuperTypes="#//AXIndexNode">
@@ -40 +40 @@
     <eOperations name="getOrCreateReference" eType="#//AXPackage"/>
     <eStructuralFeatures xsi:type="ecore:EReference" name="reference" eType="#//AXPackage"/>
-    <eStructuralFeatures xsi:type="ecore:EAttribute" name="level" eType="#//AXLevel"
-        transient="true"/>
     <eStructuralFeatures xsi:type="ecore:EReference" name="indexes" upperBound="-1"
         eType="#//AXIndex" containment="true" resolveProxies="false" eOpposite="#//AXIndex/parent"
@@ -108 +106 @@
     <eStructuralFeatures xsi:type="ecore:EReference" name="basicParent" eType="#//AXIndexNode"
         changeable="false" volatile="true" transient="true"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="level" eType="#//AXLevel"/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EEnum" name="AXEntryType">

org.axdt.axdoc.model/model/AXDocXML.xsd

@@ -103 +103 @@
     </xsd:sequence>
     <xsd:attribute name="name" type="xsd:string" use="required"/>
+    <xsd:attribute name="level" type="axdoc:AXLevel"/>
   </xsd:complexType>
 </xsd:schema>

org.axdt.axdoc.model/src/org/axdt/axdoc/model/AXDocPackage.java

@@ -347 +347 @@
 
         /**
+         * The feature id for the '<em><b>Level</b></em>' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         * @ordered
+         */
+        int AX_INDEX_NODE__LEVEL = 4;
+
+        /**
          * The number of structural features of the '<em>AX Index Node</em>' class.
          * <!-- begin-user-doc -->
@@ -353 +362 @@
          * @ordered
          */
-        int AX_INDEX_NODE_FEATURE_COUNT = 4;
+        int AX_INDEX_NODE_FEATURE_COUNT = 5;
 
         /**
@@ -402 +411 @@
 
         /**
+         * The feature id for the '<em><b>Level</b></em>' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         * @ordered
+         */
+        int AX_INDEX__LEVEL = AX_INDEX_NODE__LEVEL;
+
+        /**
          * The feature id for the '<em><b>Reference</b></em>' reference.
          * <!-- begin-user-doc -->
@@ -411 +429 @@
 
         /**
-         * The feature id for the '<em><b>Level</b></em>' attribute.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         * @ordered
-         */
-        int AX_INDEX__LEVEL = AX_INDEX_NODE_FEATURE_COUNT + 1;
-
-        /**
          * The feature id for the '<em><b>Indexes</b></em>' containment reference list.
          * <!-- begin-user-doc -->
@@ -426 +435 @@
          * @ordered
          */
-        int AX_INDEX__INDEXES = AX_INDEX_NODE_FEATURE_COUNT + 2;
+        int AX_INDEX__INDEXES = AX_INDEX_NODE_FEATURE_COUNT + 1;
 
         /**
@@ -435 +444 @@
          * @ordered
          */
-        int AX_INDEX__PARENT = AX_INDEX_NODE_FEATURE_COUNT + 3;
+        int AX_INDEX__PARENT = AX_INDEX_NODE_FEATURE_COUNT + 2;
 
         /**
@@ -444 +453 @@
          * @ordered
          */
-        int AX_INDEX_FEATURE_COUNT = AX_INDEX_NODE_FEATURE_COUNT + 4;
+        int AX_INDEX_FEATURE_COUNT = AX_INDEX_NODE_FEATURE_COUNT + 3;
 
         /**
@@ -493 +502 @@
 
         /**
+         * The feature id for the '<em><b>Level</b></em>' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         * @ordered
+         */
+        int AX_ROOT__LEVEL = AX_INDEX__LEVEL;
+
+        /**
          * The feature id for the '<em><b>Reference</b></em>' reference.
          * <!-- begin-user-doc -->
@@ -500 +518 @@
          */
         int AX_ROOT__REFERENCE = AX_INDEX__REFERENCE;
-
-        /**
-         * The feature id for the '<em><b>Level</b></em>' attribute.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @generated
-         * @ordered
-         */
-        int AX_ROOT__LEVEL = AX_INDEX__LEVEL;
 
         /**
@@ -618 +627 @@
          */
         int AX_ENTRY__BASIC_PARENT = AX_INDEX_NODE__BASIC_PARENT;
+
+        /**
+         * The feature id for the '<em><b>Level</b></em>' attribute.
+         * <!-- begin-user-doc -->
+         * <!-- end-user-doc -->
+         * @generated
+         * @ordered
+         */
+        int AX_ENTRY__LEVEL = AX_INDEX_NODE__LEVEL;
 
         /**
@@ -824 +842 @@
 
         /**
-         * Returns the meta object for the attribute '{@link org.axdt.axdoc.model.AXIndex#getLevel <em>Level</em>}'.
-         * <!-- begin-user-doc -->
-         * <!-- end-user-doc -->
-         * @return the meta object for the attribute '<em>Level</em>'.
-         * @see org.axdt.axdoc.model.AXIndex#getLevel()
-         * @see #getAXIndex()
-         * @generated
-         */
-        EAttribute getAXIndex_Level();
-
-        /**
          * Returns the meta object for class '{@link org.axdt.axdoc.model.AXRoot <em>AX Root</em>}'.
          * <!-- begin-user-doc -->
@@ -984 +991 @@
          */
         EReference getAXIndexNode_BasicParent();
+
+        /**