Content Assist, Quick Assist, and Quick Fix

Rename in File

Use Quick Assist to rename code elements that have the Rename/Refactor action enabled. That is, variables, methods, class names, parameters, imports, and states and ActionScript code inside MXML tags.

To rename all instances of a variable or method in your file, place your cursor in the selected variable or method name, and invoke Quick Assist. Then, select the Rename In File option to rename the variable or method name. Similarly, you can change the ID property of an MXML component.

Rename in Workspace

Use Quick Assist to rename code elements that have the Rename/Refactor action enabled across files in your workspace.

To rename all instances of a variable or method in your workspace, place your cursor in the selected variable or method name, and invoke Quick Assist. Then, select the Rename In Workspace option to rename the variable or method name. You can update all references to the variable or method in your workspace.

Organize Imports

Place the cursor on any import statement, and invoke Quick Assist. Then, select the option to organize imports. For more information on organizing import statements, see Organize import statements.

Generate Import Statement

If you have an undefined variable, you can place your cursor anywhere within the line of code and invoke Quick Assist. You get an option to import the component. If the component has MX and Spark equivalents, both the options appear.

For example, if you have an undefined variable btn in your code:

var btn:Button;

Place your cursor anywhere in the line of code, and press Control +1. You get options to import the Button component. If you select the Spark Button component, the import statement is created as follows:

import spark.components.Button;

Split Variable Declaration

Use Quick Assist to split a variable into two parts: variable declaration and variable initialization.

Quick Assist appears in the following contexts.

public function TestAS() 
{ 
var i:int=10; 
} 

public function TestAS() 
{ 
var i:int; 
i=10; 
} 

public function TestAS() 
{ 
    var i:int=10, j:int=20; 
} 

public function TestAS() 
{ 
    var i:int, j:int=20; 
    i=10; 
}

public function TestAS() 
{ 
    var i:int, j:int; 
    j=20; 
    i=10; 
}

Assign to Variable

When you evaluate an ActionScript expression, if the expression returns a value, you can use Quick Assist to create a variable for that expression. Quick Assist is not available for methods that do not have a return type or if the return type is void.

The name of the variable that is created is derived from the name of the function or identifier in the expression. If the derived name exists, then the name is incremented.

For example, if you have the following code:

var i:int; 
i; 

Place your cursor after "i", and invoke Quick Assist. Then, select Assign Statement To A New Local Variable. A variable "i2" is created. Because the variable i is already present, the new variable name is incremented to "i2" as follows:

var i:int; 
var i2:int = i; 

For example, Assign to Variable appears in the following contexts:

100+150

var number2:Number = 110 + 500;

var ac:ArrayCollection = new ArrayCollection(); 
ac.createCursor();

var createCursor:IViewCursor = ac.createCursor();

var ac:ArrayCollection = new ArrayCollection(); 
ac.source;

var source:Array = ac.source;

Convert Local Variable to Field

When you have local variables inside a function, Quick Assist lets you create a field in the class.

For example, if you have a variable inside a function, as follows:

var i:int = 10;

Place your cursor anywhere within the variable definition, and invoke Quick Assist. Then, select Convert Local Variable To Field. The class field is created as follows:

private var i:int;

The name of the new field is the same name as the local variable, provided there are no conflicts in the class scope. If the name exists, then the field name is incremented, and you can rename the variable or method in your file.

Convert Local Variable to Parameter

When you have a local variable inside a function, Quick Assist lets you convert the local variable into a parameter.

For example, if you have a variable inside a function, as follows:

public function method():void { 
var i:int = 10; 
}

Place your cursor anywhere within the variable definition, and invoke Quick Assist. Select Convert Local Variable To Parameter. The parameter is created as follows:

public function method(i:int):void { 
    i = 10; 
}

After the parameter is generated, you can rename all references of the parameter using linked mode.

Convert Anonymous Function to Named Function

When you have an anonymous function, you can quickly convert it to a named function using Quick Assist.

For example, if you have an anonymous function, as follows:

public function method1():void; 
{ 
    var foo:Function = function(x:int, y:int, z:int):void; 
    { 
        trace(x, y, z); 
    } 
}

public function method1():void; 
    { 
        var foo:Function = fooFunction; 
    } 
    protected function fooFunction(x:int, y:int, z:int):void; 
    { 
        trace(x, y, z); 
    }

After the function is generated, you can rename all references of the function using linked mode.

Assign Parameter to New or Existing Variable

When you have a function containing a parameter, Quick Assist lets you assign the parameter to a new instance variable.

For example, if you have a function containing a parameter, arg, as follows:

class A{ 
    function method(arg:String):void { 
    } 
}

Place your cursor within arg, and invoke Quick Assist. Then, select Assign Parameter To New Instance Variable. The statement is changed to:

class A { 
    private var arg:String; 
    function method(arg:String):void { 
    this.arg = arg; 
    } 
}

If you have instance variables already defined, you can assign the parameter to one of them.

For example, if you have a variable, myArg, defined as:

class A { 
    private var myArg:String; 
    function method(arg:String):void { 
    } 
}

Place your cursor within arg, and invoke Quick Assist. Quick Assist detects the myArg variable, and shows the option Assign Parameter To Instance Variable 'myArg'. Selecting this option, changes the statement to:

class A { 
    private var myArg:String; 
    function method(arg:String):void { 
        myArg = arg; 
    } 
}

After the variable is generated, you can rename all references of the variable using linked mode.

Create New Local Variable With Cast Type

Quick Assist lets you quickly create a cast type local variable within a conditional expression.

if(myObject is Button) { 
}

Or a while statement:

while(myObject is Button) { 
}

Place your cursor within the if or why statement, and invoke Quick Assist. Quick Assist shows you the option Create New Local Variable With Cast Type. Selecting this option generates the following conditional expression:

if(myObject is Button) { 
    var button:Button = myObject as Button; 
}

After the local variable is generated, you can rename all references of the variable using linked mode.

Replace Conditional Statement With If-Else Statement

Quick Assist lets you replace a conditional statement with an if-else statement.

For example, if you have a conditional statement, as follows:

var foo:String = bool?"Yes":"No";

Place your cursor anywhere within the condition statement, bool?"Yes":"No", and invoke Quick Assist. Then, select Replace Conditional With 'If-Else'. The if-else statement is generated, as follows:

var foo:String; 
    if (bool) 
        { 
            foo = "Yes"; 
        } 
    else 
        { 
            foo = "No"; 
        }

Add Else, Else-If, Finally, and Catch statements

If you have an If statement, you can use Quick Assist to add Else and Else-If statements.

For example, when you have an if statement:

var foo:Boolean = false; 
if(foo) { 
}

Place your cursor within if, and invoke Quick Assist. Quick Assist shows you options to add else and else-if statements. If you’ve defined an else statement already, then Quick Assist shows you an option to add an else-if statement.

Similarly, if you’ve defined a try statement, you can add finally and catch statements.

Generate Getter/Setter

Quick Assist lets you generate getters and setters (get and set accessor functions) for class variables.

For example, if you have code like the following:

private var result:ResultEvent;

Place your cursor in the variable, result, and invoke Quick Assist. Then, select the option to create the getter and setter for result. The Generate Getter/Setter dialog box appears. Using this dialog box, you can specify a new getter and setter function. For more information on generating getter and setters, see Generate get and set accessor functions.

Generate functions

Quick Assist lets you generate special functions such as labelFunction, iconFunction, and such.

For example, to create a labelFunction for the following code:

<mx:DataGrid labelFunction="lblfunc" dataTipFunction="tipFunc" />

Place your cursor within "lblfunc", and invoke Quick Assist. Then, select the option to create the labelFunction. Stub code for the function is generated as follows:

protected function lblfunc(item:Object, column:DataGridColumn):String 
    { 
    // TODO Auto-generated method stub 
    }

Generate event handlers from MXML code

Quick Assist lets you generate event handlers with custom handler names within MXML code.

For example, to generate an event handler on clicking an <mx:Button> tag, enter the following code:

<mx:Button click="clickHandler" />

Then, place your cursor within "clickHandler", invoke Quick Assist, and select generate event handler. The event handler and stub code are generated as follows:

<mx:Button click="clickHandler(event)" />

protected function clickHandler(event:MouseEvent):void 
    { 
        // TODO Auto-generated method stub 
    }

You can also generate an event handler for the following code, by pressing Control+1 anywhere within "clickHandler(event)".

<mx:Button click="clickHandler(event)" />

To customize the predefined stub code that Flash Builder generates, see Code templates.