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";
        }

Corrija una referencia ambigua haciendo que la referencia sea específica. El ejemplo siguiente utiliza la forma espacio de nombres::función para especificar el espacio de nombres que debe utilizarse:

public function ErrorExamples() {

        trace(rss::hello());
        trace(xml::hello());
    }

public override function foo():void{};

El error también puede producirse si la clase a la que se hace referencia no está definida en un espacio de nombres que está utilizándose o está definida como pública:

public class Foo{}

class D { function xx() { return 22; } }
    var d:D = new D();
    var x = new d.xx(); // error, el método no se puede utilizar como constructor
    function yy() { this.a = 22; }
    var z = new yy(); // sin error, las funciones globales se pueden utilizar como constructores.

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

Lo que sigue sí es válido:

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

En el ejemplo siguiente, la línea 3 genera un error porque no hay una función setter definida para xx.

class D { function get xx() { return 22; } }
    var d:D = new D();
    d.xx = 44; // error, es una propiedad de sólo lectura

public int z;// debería de ser 'public var z:int;'

import flash.utils.trace;
    trace "hello"

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

var sum:int = 1 + 2 + ;

Si el error indica que se esperaba un paréntesis inicial antes de _, es posible que haya omitido un paréntesis en una expresión condicional, como se muestra en el siguiente ejemplo, que se ha escrito incorrectamente a propósito:

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

var x = (5 > 2) ?
    trace(x)

El archivo a.as contiene lo siguiente, que intenta incluir al archivo b.as:

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

El archivo b.as contiene lo siguiente, que intenta incluir al archivo a.as:

include "a.as"

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

Puede que esté utilizando un supertipo en un lugar en el que se espera un subtipo. Por ejemplo:

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

La última sentencia genera un error porque intenta asignar un objeto de tipo A a una variable de tipo B.

De forma similar, lo que sigue define la función foo(), que toma un parámetro de tipo B. La sentencia foo(a); genera un error porque intenta utilizar un parámetro de tipo A:

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

Asimismo, la siguiente sentencia genera un error porque el valor devuelto para foo2() debe ser de tipo 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); } }

La siguiente sentencia generaría un error porque proporciona tres argumentos:

A.goo(1,2,3);

El siguiente ejemplo de código convierte correctamente la variable x como del mismo tipo:

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

El siguiente ejemplo de código genera un error porque la conversión de tipo de la declaración de variable y los bucles for son diferentes:

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

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

La sentencia de implementación correcta sería class C implements A {.

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

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

Sin embargo, la función g(x) incluida debajo genera el error debido a que la sentencia switch no siempre devuelve un valor.

function g(x:int):int
    {
    switch(x)
    {
          	case 1: return 1;
          	case 2: return 2:
    }
    // return 2;//se quita el comentario para eliminar el error
    }

Esta comprobación sólo se activa cuando la función declara un tipo de devolución distinto de void.

p.huh = 55;