pygments.rb 0.2.4 → 0.2.6

data/vendor/pygments-main/tests/examplefiles/scilab.sci

@@ -0,0 +1,30 @@
+// Scilab ( http://www.scilab.org/ )
+// Copyright (C) INRIA - Serge STEER
+// 
+
+function I=sub2ind(dims,varargin)
+//sub2ind is used to determine the equivalent single index
+//corresponding to a given set of subscript values.
+ 
+//I = sub2ind(dims,i1,i2,..) returns the linear index equivalent to the
+//row,  column, ... subscripts in the arrays i1,i2,..  for an matrix of
+//size dims.
+ 
+//I = sub2ind(dims,Mi) returns the linear index
+//equivalent to the n subscripts in the columns of the matrix Mi for a matrix
+//of size dims.
+ 
+  d=[1;cumprod(matrix(dims(1:$-1),-1,1))]
+  for i=1:size(varargin)
+    if varargin(i)==[] then I=[],return,end
+  end
+
+  if size(varargin)==1 then //subindices are the columns of the argument
+    I=(varargin(1)-1)*d+1
+  else //subindices are given as separated arguments
+    I=1
+    for i=1:size(varargin)
+      I=I+(varargin(i)-1)*d(i)
+    end
+  end
+endfunction

data/vendor/pygments-main/tests/examplefiles/test.bro

@@ -0,0 +1,250 @@
+@load notice
+@load utils/thresholds
+
+module SSH;
+
+export {
+	redef enum Log::ID += { SSH };
+
+	redef enum Notice::Type += {
+		Login,
+		Password_Guessing,
+		Login_By_Password_Guesser,
+		Login_From_Interesting_Hostname,
+		Bytecount_Inconsistency,
+	};
+
+	type Info: record {
+		ts:              time         &log;
+		uid:             string       &log;
+		id:              conn_id      &log;
+		status:          string       &log &optional;
+		direction:       string       &log &optional;
+		remote_location: geo_location &log &optional;
+		client:          string       &log &optional;
+		server:          string       &log &optional;
+		resp_size:       count        &log &default=0;
+		
+		## Indicate if the SSH session is done being watched.
+		done:            bool         &default=F;
+	};
+
+	const password_guesses_limit = 30 &redef;
+	
+	# The size in bytes at which the SSH connection is presumed to be
+	# successful.
+	const authentication_data_size = 5500 &redef;
+	
+	# The amount of time to remember presumed non-successful logins to build
+	# model of a password guesser.
+	const guessing_timeout = 30 mins &redef;
+
+	# The set of countries for which you'd like to throw notices upon successful login
+	#   requires Bro compiled with libGeoIP support
+	const watched_countries: set[string] = {"RO"} &redef;
+
+	# Strange/bad host names to originate successful SSH logins
+	const interesting_hostnames =
+			/^d?ns[0-9]*\./ |
+			/^smtp[0-9]*\./ |
+			/^mail[0-9]*\./ |
+			/^pop[0-9]*\./  |
+			/^imap[0-9]*\./ |
+			/^www[0-9]*\./  |
+			/^ftp[0-9]*\./  &redef;
+
+	# This is a table with orig subnet as the key, and subnet as the value.
+	const ignore_guessers: table[subnet] of subnet &redef;
+	
+	# If true, we tell the event engine to not look at further data
+	# packets after the initial SSH handshake. Helps with performance
+	# (especially with large file transfers) but precludes some
+	# kinds of analyses (e.g., tracking connection size).
+	const skip_processing_after_detection = F &redef;
+	
+	# Keeps count of how many rejections a host has had
+	global password_rejections: table[addr] of TrackCount 
+		&write_expire=guessing_timeout
+		&synchronized;
+
+	# Keeps track of hosts identified as guessing passwords
+	# TODO: guessing_timeout doesn't work correctly here.  If a user redefs
+	#       the variable, it won't take effect.
+	global password_guessers: set[addr] &read_expire=guessing_timeout+1hr &synchronized;
+	
+	global log_ssh: event(rec: Info);
+}
+
+# Configure DPD and the packet filter
+redef capture_filters += { ["ssh"] = "tcp port 22" };
+redef dpd_config += { [ANALYZER_SSH] = [$ports = set(22/tcp)] };
+
+redef record connection += {
+	ssh: Info &optional;
+};
+
+event bro_init()
+{
+	Log::create_stream(SSH, [$columns=Info, $ev=log_ssh]);
+}
+
+function set_session(c: connection)
+	{
+	if ( ! c?$ssh )
+		{
+		local info: Info;
+		info$ts=network_time();
+		info$uid=c$uid;
+		info$id=c$id;
+		c$ssh = info;
+		}
+	}
+
+function check_ssh_connection(c: connection, done: bool)
+	{
+	# If done watching this connection, just return.
+	if ( c$ssh$done )
+		return;
+	
+	# If this is still a live connection and the byte count has not
+	# crossed the threshold, just return and let the resheduled check happen later.
+	if ( !done && c$resp$size < authentication_data_size )
+		return;
+
+	# Make sure the server has sent back more than 50 bytes to filter out
+	# hosts that are just port scanning.  Nothing is ever logged if the server
+	# doesn't send back at least 50 bytes.
+	if ( c$resp$size < 50 )
+		return;
+
+	local status = "failure";
+	local direction = Site::is_local_addr(c$id$orig_h) ? "to" : "from";
+	local location: geo_location;
+	location = (direction == "to") ? lookup_location(c$id$resp_h) : lookup_location(c$id$orig_h);
+	
+	if ( done && c$resp$size < authentication_data_size )
+		{
+		# presumed failure
+		if ( c$id$orig_h !in password_rejections )
+			password_rejections[c$id$orig_h] = new_track_count();
+			
+		# Track the number of rejections
+		if ( !(c$id$orig_h in ignore_guessers &&
+		       c$id$resp_h in ignore_guessers[c$id$orig_h]) )
+			++password_rejections[c$id$orig_h]$n;
+			
+		if ( default_check_threshold(password_rejections[c$id$orig_h]) )
+			{
+			add password_guessers[c$id$orig_h];
+			NOTICE([$note=Password_Guessing,
+			        $conn=c,
+			        $msg=fmt("SSH password guessing by %s", c$id$orig_h),
+			        $sub=fmt("%d failed logins", password_rejections[c$id$orig_h]$n),
+			        $n=password_rejections[c$id$orig_h]$n]);
+			}
+		} 
+	# TODO: This is to work around a quasi-bug in Bro which occasionally 
+	#       causes the byte count to be oversized.
+	#   Watch for Gregors work that adds an actual counter of bytes transferred.
+	else if ( c$resp$size < 20000000 ) 
+		{ 
+		# presumed successful login
+		status = "success";
+		c$ssh$done = T;
+
+		if ( c$id$orig_h in password_rejections &&
+		     password_rejections[c$id$orig_h]$n > password_guesses_limit &&
+		     c$id$orig_h !in password_guessers )
+			{
+			add password_guessers[c$id$orig_h];
+			NOTICE([$note=Login_By_Password_Guesser,
+			        $conn=c,
+			        $n=password_rejections[c$id$orig_h]$n,
+			        $msg=fmt("Successful SSH login by password guesser %s", c$id$orig_h),
+			        $sub=fmt("%d failed logins", password_rejections[c$id$orig_h]$n)]);
+			}
+		
+		local message = fmt("SSH login %s %s \"%s\" \"%s\" %f %f %s (triggered with %d bytes)",
+		              direction, location$country_code, location$region, location$city,
+		              location$latitude, location$longitude,
+		              id_string(c$id), c$resp$size);
+		NOTICE([$note=Login,
+		        $conn=c,
+		        $msg=message,
+		        $sub=location$country_code]);
+		
+		# Check to see if this login came from an interesting hostname
+		when ( local hostname = lookup_addr(c$id$orig_h) )
+			{
+			if ( interesting_hostnames in hostname )
+				{
+				NOTICE([$note=Login_From_Interesting_Hostname,
+				        $conn=c,
+				        $msg=fmt("Strange login from %s", hostname),
+				        $sub=hostname]);
+				}
+			}
+			
+		if ( location$country_code in watched_countries )
+			{
+			
+			}
+			
+		}
+	else if ( c$resp$size >= 200000000 ) 
+		{
+		NOTICE([$note=Bytecount_Inconsistency,
+		        $conn=c,
+		        $msg="During byte counting in SSH analysis, an overly large value was seen.",
+		        $sub=fmt("%d",c$resp$size)]);
+		}
+
+	c$ssh$remote_location = location;
+	c$ssh$status = status;
+	c$ssh$direction = direction;
+	c$ssh$resp_size = c$resp$size;
+	
+	Log::write(SSH, c$ssh);
+	
+	# Set the "done" flag to prevent the watching event from rescheduling
+	# after detection is done.
+	c$ssh$done;
+	
+	# Stop watching this connection, we don't care about it anymore.
+	if ( skip_processing_after_detection )
+		{
+		skip_further_processing(c$id);
+		set_record_packets(c$id, F);
+		}
+	}
+
+event connection_state_remove(c: connection) &priority=-5
+	{
+	if ( c?$ssh )
+		check_ssh_connection(c, T);
+	}
+
+event ssh_watcher(c: connection)
+	{
+	local id = c$id;
+	# don't go any further if this connection is gone already!
+	if ( !connection_exists(id) )
+		return;
+
+	check_ssh_connection(c, F);
+	if ( ! c$ssh$done )
+		schedule +15secs { ssh_watcher(c) };
+	}
+
+event ssh_server_version(c: connection, version: string) &priority=5
+	{
+	set_session(c);
+	c$ssh$server = version;
+	}
+	
+event ssh_client_version(c: connection, version: string) &priority=5
+	{
+	set_session(c);
+	c$ssh$client = version;
+	schedule +15secs { ssh_watcher(c) };
+	}

data/vendor/pygments-main/tests/examplefiles/test.cs

@@ -153,6 +153,29 @@ namespace Diva.Core {
                 public OpenerTask (string fileName)
                 {
                         this.fileName = fileName;
+                        var verbatimString = @"c:\test\";
+
+                        var verbatimStringWithNewline = @"test \\ \n \t \r
+a
+b
+c";
+                        var verbatimStringWithEscapedQuotes = @"He said
+""she says \"" is not an escaped character in verbatimstrings""
+";
+
+                        int[] numbers = { 5,6,4,2,4,6,8,9,7,0 };
+                        var linqExample = from n in numbers
+                                          where n > 5
+                                          select n;
+
+                        var anotherlinqExample = from n in numbers
+                                                 orderby n descending
+                                                 select n;
+
+                        int[] someMoreNumbers = { 8,2,17,34,8,9,9,5,3,4,2,1,5 };
+                        var moreLinq = from n in numbers
+                                       join mn in moreNumbers on n equals mn + 2
+                                       select new {n, mn};
                 }
                 
                 public override void Reset ()

data/vendor/pygments-main/tests/examplefiles/test.dart

@@ -0,0 +1,23 @@
+// Greeter example from
+// <http://www.dartlang.org/docs/getting-started/interface.html>
+class Greeter implements Comparable {
+  String prefix = 'Hello,';
+  Greeter() {}
+  Greeter.withPrefix(this.prefix);
+  greet(String name) => print('$prefix $name');
+
+  int compareTo(Greeter other) => prefix.compareTo(other.prefix);
+}
+
+void main() {
+  Greeter greeter = new Greeter();
+  Greeter greeter2 = new Greeter.withPrefix('Hi,');
+
+  num result = greeter2.compareTo(greeter);
+  if (result == 0) {
+    greeter2.greet('you are the same.');
+  } else {
+    greeter2.greet('you are different.');
+  }
+}
+

data/vendor/pygments-main/tests/examplefiles/test.ecl

@@ -0,0 +1,58 @@
+/*##############################################################################
+
+    Copyright (C) 2011 HPCC Systems.
+
+    All rights reserved. This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+############################################################################## */
+
+#option ('slidingJoins', true);
+
+namesRecord :=
+            RECORD
+string20        surname;
+string10        forename;
+integer2        age;
+integer2        dadAge;
+integer2        mumAge;
+            END;
+
+namesRecord2 :=
+            record
+string10        extra;
+namesRecord;
+            end;
+
+namesTable := dataset('x',namesRecord,FLAT);
+namesTable2 := dataset('y',namesRecord2,FLAT);
+
+integer2 aveAgeL(namesRecord l) := (l.dadAge+l.mumAge)/2;
+integer2 aveAgeR(namesRecord2 r) := (r.dadAge+r.mumAge)/2;
+
+// Standard join on a function of left and right
+output(join(namesTable, namesTable2, aveAgeL(left) = aveAgeR(right)));
+
+//Several simple examples of sliding join syntax
+output(join(namesTable, namesTable2, left.age >= right.age - 10 and left.age <= right.age +10));
+output(join(namesTable, namesTable2, left.age between right.age - 10 and right.age +10));
+output(join(namesTable, namesTable2, left.age between right.age + 10 and right.age +30));
+output(join(namesTable, namesTable2, left.age between (right.age + 20) - 10 and (right.age +20) + 10));
+output(join(namesTable, namesTable2, aveAgeL(left) between aveAgeR(right)+10 and aveAgeR(right)+40));
+
+//Same, but on strings.  Also includes age to ensure sort is done by non-sliding before sliding.
+output(join(namesTable, namesTable2, left.surname between right.surname[1..10]+'AAAAAAAAAA' and right.surname[1..10]+'ZZZZZZZZZZ' and left.age=right.age));
+output(join(namesTable, namesTable2, left.surname between right.surname[1..10]+'AAAAAAAAAA' and right.surname[1..10]+'ZZZZZZZZZZ' and left.age=right.age,all));
+
+//This should not generate a self join
+output(join(namesTable, namesTable, left.age between right.age - 10 and right.age +10));
+

data/vendor/pygments-main/tests/examplefiles/test.fan

@@ -0,0 +1,818 @@
+//
+// Copyright (c) 2008, Brian Frank and Andy Frank
+// Licensed under the Academic Free License version 3.0
+//
+// History:
+//   17 Nov 08  Brian Frank  Creation
+//
+
+using compiler
+
+**
+** JavaBridge is the compiler plugin for bringing Java
+** classes into the Fantom type system.
+**
+class JavaBridge : CBridge
+{
+
+//////////////////////////////////////////////////////////////////////////
+// Constructor
+//////////////////////////////////////////////////////////////////////////
+
+  **
+  ** Construct a JavaBridge for current environment
+  **
+  new make(Compiler c, ClassPath cp := ClassPath.makeForCurrent)
+    : super(c)
+  {
+    this.cp = cp
+  }
+
+//////////////////////////////////////////////////////////////////////////
+// Namespace
+//////////////////////////////////////////////////////////////////////////
+
+  **
+  ** Map a FFI "podName" to a Java package.
+  **
+  override CPod resolvePod(Str name, Loc? loc)
+  {
+    // the empty package is used to represent primitives
+    if (name == "") return primitives
+
+    // look for package name in classpatch
+    classes := cp.classes[name]
+    if (classes == null)
+      throw CompilerErr("Java package '$name' not found", loc)
+
+    // map package to JavaPod
+    return JavaPod(this, name, classes)
+  }
+
+  **
+  ** Map class meta-data and Java members to Fantom slots
+  ** for the specified JavaType.
+  **
+  virtual Void loadType(JavaType type, Str:CSlot slots)
+  {
+    JavaReflect.loadType(type, slots)
+  }
+
+//////////////////////////////////////////////////////////////////////////
+// Call Resolution
+//////////////////////////////////////////////////////////////////////////
+
+  **
+  ** Resolve a construction call to a Java constructor.
+  **
+  override Expr resolveConstruction(CallExpr call)
+  {
+    // if the last argument is an it-block, then we know
+    // right away that we will not be passing it thru to Java,
+    // so strip it off to be appended as call to Obj.with
+    itBlock := call.args.last as ClosureExpr
+    if (itBlock != null && itBlock.isItBlock)
+      call.args.removeAt(-1)
+    else
+      itBlock = null
+
+    // if this is an interop array like IntArray/int[] use make
+    // factory otherwise look for Java constructor called <init>
+    JavaType base := call.target.ctype
+    if (base.isInteropArray)
+      call.method = base.method("make")
+    else
+      call.method = base.method("<init>")
+
+    // call resolution to deal with overloading
+    call = resolveCall(call)
+
+    // we need to create an implicit target for the Java runtime
+    // to perform the new opcode to ensure it is on the stack
+    // before the args (we don't do this for interop Array classes)
+    if (!base.isInteropArray)
+    {
+      loc := call.loc
+      call.target = CallExpr.makeWithMethod(loc, null, base.newMethod) { synthetic=true }
+    }
+
+    // if we stripped an it-block argument,
+    // add it as trailing call to Obj.with
+    if (itBlock != null) return itBlock.toWith(call)
+    return call
+  }
+
+  **
+  ** Resolve a construction chain call where a Fantom constructor
+  ** calls the super-class constructor.  Type check the arguments
+  ** and insert any conversions needed.
+  **
+  override Expr resolveConstructorChain(CallExpr call)
+  {
+    // we don't allow chaining to a this ctor for Java FFI
+    if (call.target.id !== ExprId.superExpr)
+      throw err("Must use super constructor call in Java FFI", call.loc)
+
+    // route to a superclass constructor
+    JavaType base := call.target.ctype.deref
+    call.method = base.method("<init>")
+
+    // call resolution to deal with overloading
+    return resolveCall(call)
+  }
+
+  **
+  ** Given a dot operator slot access on the given foreign
+  ** base type, determine the appopriate slot to use based on
+  ** whether parens were used
+  **   base.name    =>  noParens = true
+  **   base.name()  =>  noParens = false
+  **
+  ** In Java a given name could be bound to both a field and
+  ** a method.  In this case we only resolve the field if
+  ** no parens are used.  We also handle the special case of
+  ** Java annotations here because their element methods are
+  ** also mapped as Fantom fields (instance based mixin field).
+  **
+  override CSlot? resolveSlotAccess(CType base, Str name, Bool noParens)
+  {
+    // first try to resolve as a field
+    field := base.field(name)
+    if (field != null)
+    {
+      // if no () we used and this isn't an annotation field
+      if (noParens && (field.isStatic || !base.isMixin))
+        return field
+
+      // if we did find a field, then make sure we use that
+      // field's parent type to resolve a method (becuase the
+      // base type might be a sub-class of a Java type in which
+      // case it is unware of field/method overloads)
+      return field.parent.method(name)
+    }
+
+    // lookup method
+    return base.method(name)
+  }
+
+  **
+  ** Resolve a method call: try to find the best match
+  ** and apply any coercions needed.
+  **
+  override CallExpr resolveCall(CallExpr call)
+  {
+    // try to match against all the overloaded methods
+    matches := CallMatch[,]
+    CMethod? m := call.method
+    while (m != null)
+    {
+      match := matchCall(call, m)
+      if (match != null) matches.add(match)
+      m = m is JavaMethod ? ((JavaMethod)m).next : null
+    }
+
+    // if we have exactly one match use then use that one
+    if (matches.size == 1) return matches[0].apply(call)
+
+    // if we have multiple matches; resolve to
+    // most specific match according to JLS rules
+    // TODO: this does not correct resolve when using Fantom implicit casting
+    if (matches.size > 1)
+    {
+      best := resolveMostSpecific(matches)
+      if (best != null) return best.apply(call)
+    }
+
+    // zero or multiple ambiguous matches is a compiler error
+    s := StrBuf()
+    s.add(matches.isEmpty ? "Invalid args " : "Ambiguous call ")
+    s.add(call.name).add("(")
+    s.add(call.args.join(", ") |Expr arg->Str| { return arg.toTypeStr })
+    s.add(")")
+    throw err(s.toStr, call.loc)
+  }
+
+  **
+  ** Check if the call matches the specified overload method.
+  ** If so return method and coerced args otherwise return null.
+  **
+  internal CallMatch? matchCall(CallExpr call, CMethod m)
+  {
+    // first check if have matching numbers of args and params
+    args := call.args
+    if (m.params.size < args.size) return null
+
+    // check if each argument is ok or can be coerced
+    isErr := false
+    newArgs := args.dup
+    m.params.each |CParam p, Int i|
+    {
+      if (i >= args.size)
+      {
+        // param has a default value, then that is ok
+        if (!p.hasDefault) isErr = true
+      }
+      else
+      {
+        // ensure arg fits parameter type (or auto-cast)
+        newArgs[i] = coerce(args[i], p.paramType) |->| { isErr = true }
+      }
+    }
+    if (isErr) return null
+    return CallMatch { it.method = m; it.args = newArgs }
+  }
+
+  **
+  ** Given a list of overloaed methods find the most specific method
+  ** according to Java Language Specification 15.11.2.2.  The "informal
+  ** intuition" rule is that a method is more specific than another
+  ** if the first could be could be passed onto the second one.
+  **
+  internal static CallMatch? resolveMostSpecific(CallMatch[] matches)
+  {
+    CallMatch? best := matches[0]
+    for (i:=1; i<matches.size; ++i)
+    {
+      x := matches[i]
+      if (isMoreSpecific(best, x)) { continue }
+      if (isMoreSpecific(x, best)) { best = x; continue }
+      return null
+    }
+    return best
+  }
+
+  **
+  ** Is 'a' more specific than 'b' such that 'a' could be used
+  ** passed to 'b' without a compile time error.
+  **
+  internal static Bool isMoreSpecific(CallMatch a, CallMatch b)
+  {
+    return a.method.params.all |CParam ap, Int i->Bool|
+    {
+      bp := b.method.params[i]
+      return ap.paramType.fits(bp.paramType)
+    }
+  }
+
+//////////////////////////////////////////////////////////////////////////
+// Overrides
+//////////////////////////////////////////////////////////////////////////
+
+  **
+  ** Called during Inherit step when a Fantom slot overrides a FFI slot.
+  ** Log and throw compiler error if there is a problem.
+  **
+  override Void checkOverride(TypeDef t, CSlot base, SlotDef def)
+  {
+    // we don't allow Fantom to override Java methods with multiple
+    // overloaded versions since the Fantom type system can't actually
+    // override all the overloaded versions
+    jslot := base as JavaSlot
+    if (jslot?.next != null)
+      throw err("Cannot override Java overloaded method: '$jslot.name'", def.loc)
+
+    // route to method override checking
+    if (base is JavaMethod && def is MethodDef)
+      checkMethodOverride(t, base, def)
+  }
+
+  **
+  ** Called on method/method overrides in the checkOverride callback.
+  **
+  private Void checkMethodOverride(TypeDef t, JavaMethod base, MethodDef def)
+  {
+    // bail early if we know things aren't going to work out
+    if (base.params.size != def.params.size) return
+
+    // if the return type is primitive or Java array and the
+    // Fantom declaration matches how it is inferred into the Fan
+    // type system, then just change the return type - the compiler
+    // will impliclty do all the return coercions
+    if (isOverrideInferredType(base.returnType, def.returnType))
+    {
+      def.ret = def.inheritedRet = base.returnType
+    }
+
+    // if any of the parameters is a primitive or Java array
+    // and the Fantom declaration matches how it is inferred into
+    // the Fantom type type, then change the parameter type to
+    // the Java override type and make the Fantom type a local
+    // variable:
+    //   Java:   void foo(int a) { ... }
+    //   Fantom: Void foo(Int a) { ... }
+    //   Result: Void foo(int a_$J) { Int a := a_$J; ... }
+    //
+    base.params.eachr |CParam bp, Int i|
+    {
+      dp := def.paramDefs[i]
+      if (!isOverrideInferredType(bp.paramType, dp.paramType)) return
+
+      // add local variable: Int bar := bar_$J
+      local := LocalDefStmt(def.loc)
+      local.ctype = dp.paramType
+      local.name  = dp.name
+      local.init  = UnknownVarExpr(def.loc, null, dp.name + "_\$J")
+      def.code.stmts.insert(0, local)
+
+      // rename parameter Int bar -> int bar_$J
+      dp.name = dp.name + "_\$J"
+      dp.paramType = bp.paramType
+    }
+  }
+
+  **
+  ** When overriding a Java method check if the base type is
+  ** is a Java primitive or array and the override definition is
+  ** matches how the Java type is inferred in the Fantom type system.
+  ** If we have a match return true and we'll swizzle things in
+  ** checkMethodOverride.
+  **
+  static private Bool isOverrideInferredType(CType base, CType def)
+  {
+    // check if base class slot is a JavaType
+    java := base.toNonNullable as JavaType
+    if (java != null)
+    {
+      // allow primitives is it matches the inferred type
+      if (java.isPrimitive) return java.inferredAs == def
+
+      // allow arrays if mapped as Foo[] -> Foo?[]?
+      if (java.isArray) return java.inferredAs == def.toNonNullable && def.isNullable
+    }
+    return false
+  }
+
+//////////////////////////////////////////////////////////////////////////
+// CheckErrors
+//////////////////////////////////////////////////////////////////////////
+
+  **
+  ** Called during CheckErrors step for a type which extends
+  ** a FFI class or implements any FFI mixins.
+  **
+  override Void checkType(TypeDef def)
+  {
+    // can't subclass a primitive array like ByteArray/byte[]
+    if (def.base.deref is JavaType && def.base.deref->isInteropArray)
+    {
+      err("Cannot subclass from Java interop array: $def.base", def.loc)
+      return
+    }
+
+    // we don't allow deep inheritance of Java classes because
+    // the Fantom constructor and Java constructor model don't match
+    // up past one level of inheritance
+    // NOTE: that that when we remove this restriction we need to
+    // test how field initialization works because instance$init
+    // is almost certain to break with the current emit design
+    javaBase := def.base
+    while (javaBase != null && !javaBase.isForeign) javaBase = javaBase.base
+    if (javaBase != null && javaBase !== def.base)
+    {
+      err("Cannot subclass Java class more than one level: $javaBase", def.loc)
+      return
+    }
+
+    // ensure that when we map Fantom constructors to Java
+    // constructors that we don't have duplicate signatures
+    ctors := def.ctorDefs
+    ctors.each |MethodDef a, Int i|
+    {
+      ctors.each |MethodDef b, Int j|
+      {
+        if (i > j && areParamsSame(a, b))
+          err("Duplicate Java FFI constructor signatures: '$b.name' and '$a.name'", a.loc)
+      }
+    }
+  }
+
+  **
+  ** Do the two methods have the exact same parameter types.
+  **
+  static Bool areParamsSame(CMethod a, CMethod b)
+  {
+    if (a.params.size != b.params.size) return false
+    for (i:=0; i<a.params.size; ++i)
+    {
+      if (a.params[i].paramType != b.params[i].paramType)
+        return false
+    }
+    return true
+  }
+
+//////////////////////////////////////////////////////////////////////////
+// Coercion
+//////////////////////////////////////////////////////////////////////////
+
+  **
+  ** Return if we can make the actual type fit the expected
+  ** type, potentially using a coercion.
+  **
+  Bool fits(CType actual, CType expected)
+  {
+    // use dummy expression and route to coerce code
+    dummy := UnknownVarExpr(Loc("dummy"), null, "dummy") { ctype = actual }
+    fits := true
+    coerce(dummy, expected) |->| { fits=false }
+    return fits
+  }
+
+  **
+  ** Coerce expression to expected type.  If not a type match
+  ** then run the onErr function.
+  **
+  override Expr coerce(Expr expr, CType expected, |->| onErr)
+  {
+    // handle easy case
+    actual := expr.ctype
+    expected = expected.deref
+    if (actual == expected) return expr
+
+    // handle null literal
+    if (expr.id === ExprId.nullLiteral && expected.isNullable)
+      return expr
+
+    // handle Fantom to Java primitives
+    if (expected.pod == primitives)
+      return coerceToPrimitive(expr, expected, onErr)
+
+    // handle Java primitives to Fan
+    if (actual.pod == primitives)
+      return coerceFromPrimitive(expr, expected, onErr)
+
+    // handle Java array to Fantom list
+    if (actual.name[0] == '[')
+      return coerceFromArray(expr, expected, onErr)
+
+    // handle Fantom list to Java array
+    if (expected.name[0] == '[')
+      return coerceToArray(expr, expected, onErr)
+
+    // handle sys::Func -> Java interface
+    if (actual is FuncType && expected.isMixin && expected.toNonNullable is JavaType)
+      return coerceFuncToInterface(expr, expected.toNonNullable, onErr)
+
+    // handle special classes and interfaces for built-in Fantom
+    // classes which actually map directly to Java built-in types
+    if (actual.isBool    && boolTypes.contains(expected.toNonNullable.signature)) return box(expr)
+    if (actual.isInt     && intTypes.contains(expected.toNonNullable.signature)) return box(expr)
+    if (actual.isFloat   && floatTypes.contains(expected.toNonNullable.signature)) return box(expr)
+    if (actual.isDecimal && decimalTypes.contains(expected.toNonNullable.signature)) return expr
+    if (actual.isStr     && strTypes.contains(expected.toNonNullable.signature)) return expr
+
+     // use normal Fantom coercion behavior
+    return super.coerce(expr, expected, onErr)
+  }
+
+  **
+  ** Ensure value type is boxed.
+  **
+  private Expr box(Expr expr)
+  {
+    if (expr.ctype.isVal)
+      return TypeCheckExpr.coerce(expr, expr.ctype.toNullable)
+    else
+      return expr
+  }
+
+  **
+  ** Coerce a fan expression to a Java primitive (other
+  ** than the ones we support natively)
+  **
+  Expr coerceToPrimitive(Expr expr, JavaType expected, |->| onErr)
+  {
+    actual := expr.ctype
+
+    // sys::Int (long) -> int, short, byte
+    if (actual.isInt && expected.isPrimitiveIntLike)
+      return TypeCheckExpr.coerce(expr, expected)
+
+    // sys::Float (double) -> float
+    if (actual.isFloat && expected.isPrimitiveFloat)
+      return TypeCheckExpr.coerce(expr, expected)
+
+    // no coercion - type error
+    onErr()
+    return expr
+  }
+
+  **
+  ** Coerce a Java primitive to a Fantom type.
+  **
+  Expr coerceFromPrimitive(Expr expr, CType expected, |->| onErr)
+  {
+    actual := (JavaType)expr.ctype
+
+    // int, short, byte -> sys::Int (long)
+    if (actual.isPrimitiveIntLike)
+    {
+      if (expected.isInt || expected.isObj)
+        return TypeCheckExpr.coerce(expr, expected)
+    }
+
+    // float -> sys::Float (float)
+    if (actual.isPrimitiveFloat)
+    {
+      if (expected.isFloat || expected.isObj)
+        return TypeCheckExpr.coerce(expr, expected)
+    }
+
+    // no coercion - type error
+    onErr()
+    return expr
+  }
+
+  **
+  ** Coerce a Java array to a Fantom list.
+  **
+  Expr coerceFromArray(Expr expr, CType expected, |->| onErr)
+  {
+    actual := (JavaType)expr.ctype.toNonNullable
+
+    // if expected is array type
+    if (expected is JavaType && ((JavaType)expected).isArray)
+      if (actual.arrayOf.fits(((JavaType)expected).arrayOf)) return expr
+
+    // if expected is Obj
+    if (expected.isObj) return arrayToList(expr, actual.inferredArrayOf)
+
+    // if expected is list type
+    if (expected.toNonNullable is ListType)
+    {
+      expectedOf := ((ListType)expected.toNonNullable).v
+      if (actual.inferredArrayOf.fits(expectedOf)) return arrayToList(expr, expectedOf)
+    }
+
+    // no coercion available
+    onErr()
+    return expr
+  }
+
+  **
+  ** Generate List.make(of, expr) where expr is Object[]
+  **
+  private Expr arrayToList(Expr expr, CType of)
+  {
+    loc := expr.loc
+    ofExpr := LiteralExpr(loc, ExprId.typeLiteral, ns.typeType, of)
+    call := CallExpr.makeWithMethod(loc, null, listMakeFromArray, [ofExpr, expr])
+    call.synthetic = true
+    return call
+  }
+
+  **
+  ** Coerce a Fantom list to Java array.
+  **
+  Expr coerceToArray(Expr expr, CType expected, |->| onErr)
+  {
+    loc := expr.loc
+    expectedOf := ((JavaType)expected.toNonNullable).inferredArrayOf
+    actual := expr.ctype
+
+    // if actual is list type
+    if (actual.toNonNullable is ListType)
+    {
+      actualOf := ((ListType)actual.toNonNullable).v
+      if (actualOf.fits(expectedOf))
+      {
+        // (Foo[])list.asArray(cls)
+        clsLiteral := CallExpr.makeWithMethod(loc, null, JavaType.classLiteral(this, expectedOf))
+        asArray := CallExpr.makeWithMethod(loc, expr, listAsArray, [clsLiteral])
+        return TypeCheckExpr.coerce(asArray, expected)
+      }
+    }
+
+    // no coercion available
+    onErr()
+    return expr
+  }
+
+  **
+  ** Attempt to coerce a parameterized sys::Func expr to a Java
+  ** interface if the interface supports exactly one matching method.
+  **
+  Expr coerceFuncToInterface(Expr expr, JavaType expected, |->| onErr)
+  {
+    // check if we have exactly one abstract method in the expected type
+    loc := expr.loc
+    abstracts := expected.methods.findAll |CMethod m->Bool| { return m.isAbstract }
+    if (abstracts.size != 1) { onErr(); return expr }
+    method := abstracts.first
+
+    // check if we have a match
+    FuncType funcType := (FuncType)expr.ctype
+    if (!isFuncToInterfaceMatch(funcType, method)) { onErr(); return expr }
+
+    // check if we've already generated a wrapper for this combo
+    key := "${funcType.signature}+${method.qname}"
+    ctor := funcWrappers[key]
+    if (ctor == null)
+    {
+      ctor = generateFuncToInterfaceWrapper(expr.loc, funcType, expected, method)
+      funcWrappers[key] = ctor
+    }
+
+    // replace expr with FuncWrapperX(expr)
+    call := CallExpr.makeWithMethod(loc, null, ctor, [expr])
+    call.synthetic = true
+    return call
+  }
+
+  **
+  ** Return if the specified function type can be used to implement
+  ** the specified interface method.
+  **
+  Bool isFuncToInterfaceMatch(FuncType funcType, CMethod method)
+  {
+    // sanity check to map to callX method - can't handle more than 8 args
+    if (method.params.size > 8) return false
+
+    // check if method is match for function; first check is that
+    // method must supply all the arguments required by the function
+    if (funcType.params.size > method.params.size) return false
+
+    // check that func return type fits method return
+    retOk := method.returnType.isVoid || fits(funcType.ret, method.returnType)
+    if (!retOk) return false
+
+    // check all the method parameters fit the function parameters
+    paramsOk := funcType.params.all |CType f, Int i->Bool| { return fits(f, method.params[i].paramType) }
+    if (!paramsOk) return false
+
+    return true
+  }
+
+  **
+  ** Generate the wrapper which implements the specified expected interface
+  ** and overrides the specified method which calls the function.
+  **
+  CMethod generateFuncToInterfaceWrapper(Loc loc, FuncType funcType, CType expected, CMethod method)
+  {
+    //   Fantom: func typed as |Str|
+    //   Java:   interface Foo { void bar(String) }
+    //   Result: FuncWrapperX(func)
+    //
+    //   class FuncWrapperX : Foo
+    //   {
+    //     new make(Func f) { _func = f }
+    //     override Void bar(Str a) { _func.call(a) }
+    //     Func _func
+    //   }
+
+    // generate FuncWrapper class
+    name := "FuncWrapper" + funcWrappers.size
+    cls := TypeDef(ns, loc, compiler.types[0].unit, name, FConst.Internal + FConst.Synthetic)
+    cls.base = ns.objType
+    cls.mixins = [expected]
+    addTypeDef(cls)
+
+    // generate FuncWrapper._func field
+    field := FieldDef(loc, cls)
+    ((SlotDef)field).name = "_func"
+    ((DefNode)field).flags = FConst.Private + FConst.Storage + FConst.Synthetic
+    field.fieldType = funcType
+    cls.addSlot(field)
+
+    // generate FuncWrapper.make constructor
+    ctor := MethodDef(loc, cls, "make", FConst.Internal + FConst.Ctor + FConst.Synthetic)
+    ctor.ret  = ns.voidType
+    ctor.paramDefs = [ParamDef(loc, funcType, "f")]
+    ctor.code = Block.make(loc)
+    ctor.code.stmts.add(BinaryExpr.makeAssign(
+      FieldExpr(loc, ThisExpr(loc), field),
+      UnknownVarExpr(loc, null, "f")).toStmt)
+    ctor.code.stmts.add(ReturnStmt.make(loc))
+    cls.addSlot(ctor)
+
+    // generate FuncWrapper override of abstract method
+    over := MethodDef(loc, cls, method.name, FConst.Public + FConst.Override + FConst.Synthetic)
+    over.ret = method.returnType
+    over.paramDefs = ParamDef[,]
+    over.code = Block.make(loc)
+    callArity := "call"
+    call := CallExpr.makeWithMethod(loc, FieldExpr(loc, ThisExpr(loc), field), funcType.method(callArity))
+    method.params.each |CParam param, Int i|
+    {
+      paramName := "p$i"
+      over.params.add(ParamDef(loc, param.paramType, paramName))
+      if (i < funcType.params.size)
+        call.args.add(UnknownVarExpr(loc, null, paramName))
+    }
+    if (method.returnType.isVoid)
+      over.code.stmts.add(call.toStmt).add(ReturnStmt(loc))
+    else
+      over.code.stmts.add(ReturnStmt(loc, call))
+    cls.addSlot(over)
+
+    // return the ctor which we use for coercion
+    return ctor
+  }
+
+//////////////////////////////////////////////////////////////////////////
+// Reflection
+//////////////////////////////////////////////////////////////////////////
+
+  **
+  ** Get a CMethod representation for 'List.make(Type, Object[])'
+  **
+  once CMethod listMakeFromArray()
+  {
+    return JavaMethod(
+      this.ns.listType,
+      "make",
+      FConst.Public + FConst.Static,
+      this.ns.listType.toNullable,
+      [
+        JavaParam("of", this.ns.typeType),
+        JavaParam("array", objectArrayType)
+      ])
+  }
+
+  **
+  ** Get a CMethod representation for 'Object[] List.asArray()'
+  **
+  once CMethod listAsArray()
+  {
+    return JavaMethod(
+      this.ns.listType,
+      "asArray",
+      FConst.Public,
+      objectArrayType,
+      [JavaParam("cls", classType)])
+  }
+
+  **
+  ** Get a CType representation for 'java.lang.Class'
+  **
+  once JavaType classType()
+  {
+    return ns.resolveType("[java]java.lang::Class")
+  }
+
+  **
+  ** Get a CType representation for 'java.lang.Object[]'
+  **
+  once JavaType objectArrayType()
+  {
+    return ns.resolveType("[java]java.lang::[Object")
+  }
+
+//////////////////////////////////////////////////////////////////////////
+// Fields
+//////////////////////////////////////////////////////////////////////////
+
+  const static Str[] boolTypes := Str[
+    "[java]java.io::Serializable",
+    "[java]java.lang::Comparable",
+  ]
+
+  const static Str[] intTypes := Str[
+    "[java]java.lang::Number",
+    "[java]java.io::Serializable",
+    "[java]java.lang::Comparable",
+  ]
+
+  const static Str[] floatTypes := Str[
+    "[java]java.lang::Number",
+    "[java]java.io::Serializable",
+    "[java]java.lang::Comparable",
+  ]
+
+  const static Str[] decimalTypes := Str[
+    "[java]java.lang::Number",
+    "[java]java.io::Serializable",
+    "[java]java.lang::Comparable",
+  ]
+
+  const static Str[] strTypes := Str[
+    "[java]java.io::Serializable",
+    "[java]java.lang::CharSequence",
+    "[java]java.lang::Comparable",
+  ]
+
+  JavaPrimitives primitives := JavaPrimitives(this)
+  ClassPath cp
+
+  private Str:CMethod funcWrappers := Str:CMethod[:]  // funcType+method:ctor
+
+}
+
+**************************************************************************
+** CallMatch
+**************************************************************************
+
+internal class CallMatch
+{
+  CallExpr apply(CallExpr call)
+  {
+    call.args   = args
+    call.method = method
+    call.ctype  = method.isCtor ? method.parent : method.returnType
+    return call
+  }
+
+  override Str toStr() { return method.signature }
+
+  CMethod? method    // matched method
+  Expr[]? args       // coerced arguments
+}