private namespace rss;
	private namespace xml;
        
	public function ErrorExamples() {
  	    use namespace rss;
   	    use namespace xml;
	    trace(hello());
	}
        
   	rss function hello():String {
      	    return "hola";
        }
        
        xml function hello():String {
            return "foo";
        }

Correct an ambiguous reference by making the reference specific. The following example uses the form namespace::function to specify which namespace to use:

public function ErrorExamples() {
            
            trace(rss::hello());
            trace(xml::hello());
        }

public override function foo():void{};

The error can also occur if the class being referenced is not defined in a namespace that is in use or is not defined as public:

public class Foo{}

public function set gamma(g:Number):Number;

The following is valid:

public function set gamma(g:Number):void;

In the following example, line 3 generates an error because there is no setter function defined for xx:

class D { function get xx() { return 22; } }
	var d:D = new D();
	d.xx = 44; // error, property is read-only

import flash.util.trace;
                 trace "hello"

switch(x)
	{
	print(2);
	case 0:  print(0); 
	break
	}

var sum:int = 1 + 2 + ;

If the error says "Expecting left parenthesis before _," you may have omitted a parenthesis from a conditional expression, as shown here in this example which is intentionally incorrect:

var fact:int = 1 * 2 * 3;
if fact > 2 {
	var bigger:Boolean = true;
}

if () {
	var x:int = 4;
}

File a.as contains the following, which attempts to include the file b.as:

import foo.bar.baz;
	include "b.as"
	print(2);

File b.as contains the following, which attempts to include the file a.as:

include "a.as"

class a extends b { }
	class b extends a { }

You are using a supertype where a subtype is expected. For example, the following generates this error because it creates class A and then creates class B, which in turn extends class A:

class A {}
	var a:A = new A(); 
	class B extends A { function f() }
	var b : B = a // error

The last statement generates an error because it attempts to assign an object of type B to a variable of type A.

Similarly, the following defines the foo() function, which takes a parameter of type B. The statement foo(a); generates an error because it attempts to use a parameter of type A:

function foo(x:B) { }
	foo(a);

Also, the following statement generates an error because the returned value for foo2() must be type B:

function foo2():B { return new A(); }

var i:int = 44;
var str:String = i.assortment;

huh = 55;

class A { static function goo(x:int,y:int) 
	{ return(x+y); } }

The following statement would generate an error because it provides three arguments:

A.goo(1,2,3);

The following code example correctly casts the variable x as the same type:

function test()
	{
	var x:int = 3;
	for(var x:int = 33; x < 55; x++)
	print(x);
	for(var x:int = 11; x < 33; x++)
	print(x)
	}

The following code example generates an error because the type casting in the variable declaration and the for loops are different:

function test()
	{
var x:String = "The answer is";
for(var x:int = 33; x < 55; x++) // error
print(x);
for(var x:unit = 11; x < 33; x++) // error
print(x)
}

interface A {  public function f();  };
  	  class C implements A,A {
		public function f() { print("f"); }
  	}

The correct implementing statement should be class C implements A {.

function topLevel() { print("top"); }
	topLevel = function() { print("replacement works in ~");
	} // error

function f(x):int
	{
 	if (x)
    	  return 2;
 	else
    	  return 3;
	} // no error

However, the function g(x) below generates the error because the switch statement does not always return a value.

function g(x:int):int
	{
   	switch(x)
   	{
      	  case 1: return 1;
      	  case 2: return 2:
   	}
	// return 2;//uncomment to remove the error
	}

This checking is enabled only when the function declares a return type other than void.